{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp models.TSTPlus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TSTPlus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an unofficial PyTorch implementation by Ignacio Oguiza of  - oguiza@timeseriesAI.co based on:\n",
    "\n",
    "* George Zerveas et al. A Transformer-based Framework for Multivariate Time Series Representation Learning, in Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD '21), August 14--18, 2021. ArXiV version: https://arxiv.org/abs/2010.02803\n",
    "* Official implementation: https://github.com/gzerveas/mvts_transformer\n",
    "\n",
    "```bash\n",
    "@inproceedings{10.1145/3447548.3467401,\n",
    "author = {Zerveas, George and Jayaraman, Srideepika and Patel, Dhaval and Bhamidipaty, Anuradha and Eickhoff, Carsten},\n",
    "title = {A Transformer-Based Framework for Multivariate Time Series Representation Learning},\n",
    "year = {2021},\n",
    "isbn = {9781450383325},\n",
    "publisher = {Association for Computing Machinery},\n",
    "address = {New York, NY, USA},\n",
    "url = {https://doi.org/10.1145/3447548.3467401},\n",
    "doi = {10.1145/3447548.3467401},\n",
    "booktitle = {Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery &amp; Data Mining},\n",
    "pages = {2114–2124},\n",
    "numpages = {11},\n",
    "keywords = {regression, framework, multivariate time series, classification, transformer, deep learning, self-supervised learning, unsupervised learning, imputation},\n",
    "location = {Virtual Event, Singapore},\n",
    "series = {KDD '21}\n",
    "}\n",
    "```\n",
    "\n",
    "* Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., ... & Polosukhin, I. (2017). [Attention is all you need. In Advances in neural information processing systems (pp. 5998-6008).](https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf)\n",
    "\n",
    "* He, R., Ravula, A., Kanagal, B., & Ainslie, J. (2020). Realformer: Transformer Likes Informed Attention. arXiv preprint arXiv:2012.11747.\n",
    "\n",
    "This implementation is adapted to work with the rest of the `tsai` library, and contain some hyperparameters that are not available in the original implementation. I included them for experimenting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from typing import Callable\n",
    "from tsai.imports import *\n",
    "from tsai.utils import *\n",
    "from tsai.models.layers import *\n",
    "from tsai.models.utils import *\n",
    "from tsai.models.positional_encoders import *\n",
    "from tsai.data.core import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|exporti    \n",
    "class _TSTEncoderLayer(Module):\n",
    "    def __init__(self, q_len, d_model, n_heads, d_k=None, d_v=None, d_ff=256, store_attn=False,\n",
    "                 norm='BatchNorm', attn_dropout=0, dropout=0., bias=True, activation=\"gelu\", res_attention=False, pre_norm=False):\n",
    "\n",
    "        assert not d_model%n_heads, f\"d_model ({d_model}) must be divisible by n_heads ({n_heads})\"\n",
    "        d_k = ifnone(d_k, d_model // n_heads)\n",
    "        d_v = ifnone(d_v, d_model // n_heads)\n",
    "\n",
    "        # Multi-Head attention\n",
    "        self.res_attention = res_attention\n",
    "        self.self_attn = MultiheadAttention(d_model, n_heads, d_k, d_v, attn_dropout=attn_dropout, proj_dropout=dropout, res_attention=res_attention)\n",
    "\n",
    "        # Add & Norm\n",
    "        self.dropout_attn = nn.Dropout(dropout)\n",
    "        if \"batch\" in norm.lower():\n",
    "            self.norm_attn = nn.Sequential(Transpose(1,2), nn.BatchNorm1d(d_model), Transpose(1,2))\n",
    "        else: \n",
    "            self.norm_attn = nn.LayerNorm(d_model)\n",
    "\n",
    "        # Position-wise Feed-Forward\n",
    "        self.ff = nn.Sequential(nn.Linear(d_model, d_ff, bias=bias), \n",
    "                                get_act_fn(activation), \n",
    "                                nn.Dropout(dropout), \n",
    "                                nn.Linear(d_ff, d_model, bias=bias))\n",
    "\n",
    "        # Add & Norm\n",
    "        self.dropout_ffn = nn.Dropout(dropout)\n",
    "        if \"batch\" in norm.lower():\n",
    "            self.norm_ffn = nn.Sequential(Transpose(1,2), nn.BatchNorm1d(d_model), Transpose(1,2))\n",
    "        else: \n",
    "            self.norm_ffn = nn.LayerNorm(d_model)\n",
    "        \n",
    "        self.pre_norm = pre_norm\n",
    "        self.store_attn = store_attn\n",
    "\n",
    "    def forward(self, src:Tensor, prev:Optional[Tensor]=None, key_padding_mask:Optional[Tensor]=None, attn_mask:Optional[Tensor]=None) -> Tensor:\n",
    "\n",
    "        # Multi-Head attention sublayer\n",
    "        if self.pre_norm:\n",
    "            src = self.norm_attn(src)\n",
    "        ## Multi-Head attention\n",
    "        if self.res_attention:\n",
    "            src2, attn, scores = self.self_attn(src, src, src, prev, key_padding_mask=key_padding_mask, attn_mask=attn_mask)\n",
    "        else:\n",
    "            src2, attn = self.self_attn(src, src, src, key_padding_mask=key_padding_mask, attn_mask=attn_mask)\n",
    "        if self.store_attn: \n",
    "            self.attn = attn\n",
    "        ## Add & Norm\n",
    "        src = src + self.dropout_attn(src2) # Add: residual connection with residual dropout\n",
    "        if not self.pre_norm:\n",
    "            src = self.norm_attn(src)\n",
    "\n",
    "        # Feed-forward sublayer\n",
    "        if self.pre_norm:\n",
    "            src = self.norm_ffn(src)\n",
    "        ## Position-wise Feed-Forward\n",
    "        src2 = self.ff(src)\n",
    "        ## Add & Norm\n",
    "        src = src + self.dropout_ffn(src2) # Add: residual connection with residual dropout\n",
    "        if not self.pre_norm:\n",
    "            src = self.norm_ffn(src)\n",
    "\n",
    "        if self.res_attention:\n",
    "            return src, scores\n",
    "        else:\n",
    "            return src"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "attn_mask torch.Size([50, 50]) key_padding_mask torch.Size([16, 50])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([16, 50, 128])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = torch.rand(16, 50, 128)\n",
    "attn_mask = torch.triu(torch.ones(50, 50)) # shape: q_len x q_len\n",
    "key_padding_mask = torch.zeros(16, 50)\n",
    "key_padding_mask[[1, 3, 6, 15], -10:] = 1\n",
    "key_padding_mask = key_padding_mask.bool()\n",
    "print('attn_mask', attn_mask.shape, 'key_padding_mask', key_padding_mask.shape)\n",
    "encoder = _TSTEncoderLayer(q_len=50, d_model=128, n_heads=8, d_k=None, d_v=None, d_ff=512, attn_dropout=0., dropout=0.1, store_attn=True, activation='gelu')\n",
    "output = encoder(t, key_padding_mask=key_padding_mask, attn_mask=attn_mask)\n",
    "output.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cmap='viridis'\n",
    "figsize=(6,5)\n",
    "plt.figure(figsize=figsize)\n",
    "plt.pcolormesh(encoder.attn[0][0].detach().cpu().numpy(), cmap=cmap)\n",
    "plt.title('Self-attention map')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|exporti\n",
    "class _TSTEncoder(Module):\n",
    "    def __init__(self, q_len, d_model, n_heads, d_k=None, d_v=None, d_ff=None, norm='BatchNorm', attn_dropout=0., dropout=0., activation='gelu', \n",
    "                 res_attention=False, n_layers=1, pre_norm=False, store_attn=False):\n",
    "        self.layers = nn.ModuleList([_TSTEncoderLayer(q_len, d_model, n_heads=n_heads, d_k=d_k, d_v=d_v, d_ff=d_ff, norm=norm, \n",
    "                                                      attn_dropout=attn_dropout, dropout=dropout, \n",
    "                                                      activation=activation, res_attention=res_attention, \n",
    "                                                      pre_norm=pre_norm, store_attn=store_attn) for i in range(n_layers)])\n",
    "        self.res_attention = res_attention\n",
    "\n",
    "    def forward(self, src:Tensor, key_padding_mask:Optional[Tensor]=None, attn_mask:Optional[Tensor]=None):\n",
    "        output = src\n",
    "        scores = None\n",
    "        if self.res_attention:\n",
    "            for mod in self.layers: output, scores = mod(output, prev=scores, key_padding_mask=key_padding_mask, attn_mask=attn_mask)\n",
    "            return output\n",
    "        else:\n",
    "            for mod in self.layers: output = mod(output, key_padding_mask=key_padding_mask, attn_mask=attn_mask)\n",
    "            return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|exporti\n",
    "class _TSTBackbone(Module):\n",
    "    def __init__(self, c_in, seq_len, max_seq_len=512,\n",
    "                 n_layers=3, d_model=128, n_heads=16, d_k=None, d_v=None,\n",
    "                 d_ff=256, norm='BatchNorm', attn_dropout=0., dropout=0., act=\"gelu\", store_attn=False,\n",
    "                 key_padding_mask='auto', padding_var=None, attn_mask=None, res_attention=True, pre_norm=False,\n",
    "                 pe='zeros', learn_pe=True, verbose=False, **kwargs):\n",
    "\n",
    "        # Input encoding\n",
    "        q_len = seq_len\n",
    "        self.new_q_len = False\n",
    "        if max_seq_len is not None and seq_len > max_seq_len: # Control temporal resolution\n",
    "            self.new_q_len = True\n",
    "            q_len = max_seq_len\n",
    "            tr_factor = math.ceil(seq_len / q_len)\n",
    "            total_padding = (tr_factor * q_len - seq_len)\n",
    "            padding = (total_padding // 2, total_padding - total_padding // 2)\n",
    "            self.W_P = nn.Sequential(Pad1d(padding), Conv1d(c_in, d_model, kernel_size=tr_factor, padding=0, stride=tr_factor))\n",
    "            pv(f'temporal resolution modified: {seq_len} --> {q_len} time steps: kernel_size={tr_factor}, stride={tr_factor}, padding={padding}.\\n', verbose)\n",
    "        elif kwargs:\n",
    "            self.new_q_len = True\n",
    "            t = torch.rand(1, 1, seq_len)\n",
    "            q_len = Conv1d(1, 1, **kwargs)(t).shape[-1]\n",
    "            self.W_P = Conv1d(c_in, d_model, **kwargs) # Eq 2\n",
    "            pv(f'Conv1d with kwargs={kwargs} applied to input to create input encodings\\n', verbose)\n",
    "        else:\n",
    "            self.W_P = nn.Linear(c_in, d_model)        # Eq 1: projection of feature vectors onto a d-dim vector space\n",
    "        self.seq_len = q_len\n",
    "\n",
    "        # Positional encoding\n",
    "        self.W_pos = self._positional_encoding(pe, learn_pe, q_len, d_model)\n",
    "\n",
    "        # Residual dropout\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "        # Encoder\n",
    "        self.encoder = _TSTEncoder(q_len, d_model, n_heads, d_k=d_k, d_v=d_v, d_ff=d_ff, norm=norm, attn_dropout=attn_dropout, dropout=dropout, \n",
    "                                   pre_norm=pre_norm, activation=act, res_attention=res_attention, n_layers=n_layers, store_attn=store_attn)\n",
    "        self.transpose = Transpose(-1, -2, contiguous=True)\n",
    "        self.key_padding_mask, self.padding_var, self.attn_mask = key_padding_mask, padding_var, attn_mask\n",
    "\n",
    "    def forward(self, inp) -> Tensor:  \n",
    "        r\"\"\"Pass the input through the TST backbone.\n",
    "        Args:\n",
    "            inp: input (optionally with padding mask. 1s (meaning padded) in padding mask will be ignored while 0s (non-padded) will be unchanged.)\n",
    "        Shape:\n",
    "            There are 3 options: \n",
    "            1. inp: Tensor containing just time series data [bs x nvars x q_len] \n",
    "            2. inp: Tensor containing time series data plus a padding feature in the last channel [bs x (nvars + 1) x q_len]\n",
    "            3. inp: tuple containing a tensor with time series data plus a padding mask per batch ([bs x nvars x q_len] , [bs x q_len] )\n",
    "        \"\"\"\n",
    "\n",
    "        # x and padding mask\n",
    "        if isinstance(inp, tuple): x, key_padding_mask = inp\n",
    "        elif self.key_padding_mask == 'auto': x, key_padding_mask = self._key_padding_mask(inp) # automatically identify padding mask\n",
    "        elif self.key_padding_mask == -1: x, key_padding_mask = inp[:, :-1], inp[:, -1]         # padding mask is the last channel\n",
    "        else: x, key_padding_mask = inp, None\n",
    "\n",
    "        # Input encoding\n",
    "        if self.new_q_len: u = self.W_P(x).transpose(2,1) # Eq 2        # u: [bs x d_model x q_len] transposed to [bs x q_len x d_model]\n",
    "        else: u = self.W_P(x.transpose(2,1))              # Eq 1        # u: [bs x q_len x nvars] converted to [bs x q_len x d_model]\n",
    "\n",
    "        # Positional encoding\n",
    "        u = self.dropout(u + self.W_pos)\n",
    "\n",
    "        # Encoder\n",
    "        z = self.encoder(u, key_padding_mask=key_padding_mask, attn_mask=self.attn_mask)    # z: [bs x q_len x d_model]\n",
    "        z = self.transpose(z)                                                               # z: [bs x d_model x q_len]\n",
    "        if key_padding_mask is not None: \n",
    "            z = z * torch.logical_not(key_padding_mask.unsqueeze(1))  # zero-out padding embeddings\n",
    "        return z\n",
    "\n",
    "    def _positional_encoding(self, pe, learn_pe, q_len, d_model):\n",
    "        # Positional encoding\n",
    "        if pe == None:\n",
    "            W_pos = torch.empty((q_len, d_model)) # pe = None and learn_pe = False can be used to measure impact of pe\n",
    "            nn.init.uniform_(W_pos, -0.02, 0.02)\n",
    "            learn_pe = False\n",
    "        elif pe == 'zero': \n",
    "            W_pos = torch.empty((q_len, 1))\n",
    "            nn.init.uniform_(W_pos, -0.02, 0.02)\n",
    "        elif pe == 'zeros': \n",
    "            W_pos = torch.empty((q_len, d_model))\n",
    "            nn.init.uniform_(W_pos, -0.02, 0.02)\n",
    "        elif pe == 'normal' or pe == 'gauss':\n",
    "            W_pos = torch.zeros((q_len, 1))\n",
    "            torch.nn.init.normal_(W_pos, mean=0.0, std=0.1)\n",
    "        elif pe == 'uniform':\n",
    "            W_pos = torch.zeros((q_len, 1))\n",
    "            nn.init.uniform_(W_pos, a=0.0, b=0.1)\n",
    "        elif pe == 'lin1d': W_pos = Coord1dPosEncoding(q_len, exponential=False, normalize=True)\n",
    "        elif pe == 'exp1d': W_pos = Coord1dPosEncoding(q_len, exponential=True, normalize=True)\n",
    "        elif pe == 'lin2d': W_pos = Coord2dPosEncoding(q_len, d_model, exponential=False, normalize=True)\n",
    "        elif pe == 'exp2d': W_pos = Coord2dPosEncoding(q_len, d_model, exponential=True, normalize=True)\n",
    "        elif pe == 'sincos': W_pos = PositionalEncoding(q_len, d_model, normalize=True)\n",
    "        else: raise ValueError(f\"{pe} is not a valid pe (positional encoder. Available types: 'gauss'=='normal', \\\n",
    "            'zeros', 'zero', uniform', 'lin1d', 'exp1d', 'lin2d', 'exp2d', 'sincos', None.)\")\n",
    "        return nn.Parameter(W_pos, requires_grad=learn_pe)\n",
    "\n",
    "    def _key_padding_mask(self, x):\n",
    "        if self.padding_var is not None:\n",
    "            mask = TSMaskTensor(x[:, self.padding_var] == 1)            # key_padding_mask: [bs x q_len]\n",
    "            return x, mask\n",
    "        else:\n",
    "            mask = torch.isnan(x)\n",
    "            x[mask] = 0\n",
    "            if mask.any():\n",
    "                mask = TSMaskTensor((mask.float().mean(1)==1).bool())   # key_padding_mask: [bs x q_len]\n",
    "                return x, mask\n",
    "            else:\n",
    "                return x, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class TSTPlus(nn.Sequential):\n",
    "    \"\"\"TST (Time Series Transformer) is a Transformer that takes continuous time series as inputs\"\"\"\n",
    "    def __init__(self, c_in:int, c_out:int, seq_len:int, max_seq_len:Optional[int]=512,\n",
    "                 n_layers:int=3, d_model:int=128, n_heads:int=16, d_k:Optional[int]=None, d_v:Optional[int]=None,\n",
    "                 d_ff:int=256, norm:str='BatchNorm', attn_dropout:float=0., dropout:float=0., act:str=\"gelu\", key_padding_mask:bool='auto', \n",
    "                 padding_var:Optional[int]=None, attn_mask:Optional[Tensor]=None, res_attention:bool=True, pre_norm:bool=False, store_attn:bool=False,\n",
    "                 pe:str='zeros', learn_pe:bool=True, flatten:bool=True, fc_dropout:float=0.,\n",
    "                 concat_pool:bool=False, bn:bool=False, custom_head:Optional[Callable]=None,\n",
    "                 y_range:Optional[tuple]=None, verbose:bool=False, **kwargs):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            c_in: the number of features (aka variables, dimensions, channels) in the time series dataset.\n",
    "            c_out: the number of target classes.\n",
    "            seq_len: number of time steps in the time series.\n",
    "            max_seq_len: useful to control the temporal resolution in long time series to avoid memory issues. Default=512.\n",
    "            d_model: total dimension of the model (number of features created by the model). Default: 128 (range(64-512))\n",
    "            n_heads:  parallel attention heads. Default:16 (range(8-16)).\n",
    "            d_k: size of the learned linear projection of queries and keys in the MHA. Usual values: 16-512. Default: None -> (d_model/n_heads) = 32.\n",
    "            d_v: size of the learned linear projection of values in the MHA. Usual values: 16-512. Default: None -> (d_model/n_heads) = 32.\n",
    "            d_ff: the dimension of the feedforward network model. Default: 512 (range(256-512))\n",
    "            norm: flag to indicate whether BatchNorm (default) or LayerNorm is used in the encoder layers.\n",
    "            attn_dropout: dropout applied to the attention scores\n",
    "            dropout: amount of dropout applied to all linear layers except q,k&v projections in the encoder.\n",
    "            act: the activation function of intermediate layer, relu or gelu.\n",
    "            key_padding_mask:   a boolean padding mask will be applied to attention if 'auto' a mask to those steps in a sample where all features are nan.\n",
    "                                Other options include: True -->tuple (x, key_padding_mask), -1 --> key_padding_mask is the last channel, False: no mask.\n",
    "            padding_var: (optional) an int indicating the variable that contains the padded steps (0: non-padded, 1: padded). \n",
    "            attn_mask: a boolean mask will be applied to attention if a tensor of shape [min(seq_len, max_seq_len) x min(seq_len, max_seq_len)] if provided.\n",
    "            res_attention: if True Residual MultiheadAttention is applied.\n",
    "            pre_norm: if True normalization will be applied as the first step in the sublayers. Defaults to False\n",
    "            store_attn: can be used to visualize attention weights. Default: False.\n",
    "            n_layers: number of layers (or blocks) in the encoder. Default: 3 (range(1-4))\n",
    "            pe: type of positional encoder.\n",
    "                Available types (for experimenting): None, 'exp1d', 'lin1d', 'exp2d', 'lin2d', 'sincos', 'gauss' or 'normal',\n",
    "                'uniform', 'zero', 'zeros' (default, as in the paper).\n",
    "            learn_pe: learned positional encoder (True, default) or fixed positional encoder.\n",
    "            flatten: this will flatten the encoder output to be able to apply an mlp type of head (default=False)\n",
    "            fc_dropout: dropout applied to the final fully connected layer.\n",
    "            concat_pool: indicates if global adaptive concat pooling will be used instead of global adaptive pooling.\n",
    "            bn: indicates if batchnorm will be applied to the head.\n",
    "            custom_head: custom head that will be applied to the network. It must contain all kwargs (pass a partial function)\n",
    "            y_range: range of possible y values (used in regression tasks).\n",
    "            kwargs: nn.Conv1d kwargs. If not {}, a nn.Conv1d with those kwargs will be applied to original time series.\n",
    "        Input shape:\n",
    "            x: bs (batch size) x nvars (aka features, variables, dimensions, channels) x seq_len (aka time steps)\n",
    "            attn_mask: q_len x q_len\n",
    "            As mentioned in the paper, the input must be standardized by_var based on the entire training set.\n",
    "        \"\"\"\n",
    "        # Backbone\n",
    "        backbone = _TSTBackbone(c_in, seq_len=seq_len, max_seq_len=max_seq_len,\n",
    "                                n_layers=n_layers, d_model=d_model, n_heads=n_heads, d_k=d_k, d_v=d_v, d_ff=d_ff, \n",
    "                                attn_dropout=attn_dropout, dropout=dropout, act=act, key_padding_mask=key_padding_mask, padding_var=padding_var,\n",
    "                                attn_mask=attn_mask, res_attention=res_attention, pre_norm=pre_norm, store_attn=store_attn, \n",
    "                                pe=pe, learn_pe=learn_pe, verbose=verbose, **kwargs)\n",
    "\n",
    "        # Head\n",
    "        self.head_nf = d_model\n",
    "        self.c_out = c_out\n",
    "        self.seq_len = backbone.seq_len\n",
    "        if custom_head is not None:\n",
    "            if isinstance(custom_head, nn.Module): head = custom_head\n",
    "            else: head = custom_head(self.head_nf, c_out, seq_len)\n",
    "        else: head = self.create_head(self.head_nf, c_out, self.seq_len, act=act, flatten=flatten, concat_pool=concat_pool,\n",
    "                                           fc_dropout=fc_dropout, bn=bn, y_range=y_range)\n",
    "        super().__init__(OrderedDict([('backbone', backbone), ('head', head)]))\n",
    "\n",
    "\n",
    "    def create_head(self, nf, c_out, seq_len, flatten=True, concat_pool=False, act=\"gelu\", fc_dropout=0., bn=False, y_range=None):\n",
    "        layers = [get_act_fn(act)]\n",
    "        if flatten:\n",
    "            nf *= seq_len\n",
    "            layers += [Flatten()]\n",
    "        else:\n",
    "            if concat_pool: nf *= 2\n",
    "            layers = [GACP1d(1) if concat_pool else GAP1d(1)]\n",
    "        layers += [LinBnDrop(nf, c_out, bn=bn, p=fc_dropout)]\n",
    "        if y_range: layers += [SigmoidRange(*y_range)]\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "\n",
    "    def show_pe(self, cmap='viridis', figsize=None):\n",
    "        plt.figure(figsize=figsize)\n",
    "        plt.pcolormesh(self.backbone.W_pos.detach().cpu().T, cmap=cmap)\n",
    "        plt.title('Positional Encoding')\n",
    "        plt.colorbar()\n",
    "        plt.show()\n",
    "        plt.figure(figsize=figsize)\n",
    "        plt.title('Positional Encoding - value along time axis')\n",
    "        plt.plot(F.relu(self.backbone.W_pos.data).mean(1).cpu())\n",
    "        plt.plot(-F.relu(-self.backbone.W_pos.data).mean(1).cpu())\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tsai.models.utils import build_ts_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model parameters: 470018\n"
     ]
    }
   ],
   "source": [
    "bs = 8\n",
    "c_in = 9  # aka channels, features, variables, dimensions\n",
    "c_out = 2\n",
    "seq_len = 1_500\n",
    "\n",
    "xb = torch.randn(bs, c_in, seq_len).to(device)\n",
    "\n",
    "# standardize by channel by_var based on the training set\n",
    "xb = (xb - xb.mean((0, 2), keepdim=True)) / xb.std((0, 2), keepdim=True)\n",
    "\n",
    "# Settings\n",
    "max_seq_len = 256\n",
    "d_model = 128\n",
    "n_heads = 16\n",
    "d_k = d_v = None  # if None --> d_model // n_heads\n",
    "d_ff = 256\n",
    "norm = \"BatchNorm\"\n",
    "dropout = 0.1\n",
    "activation = \"gelu\"\n",
    "n_layers = 3\n",
    "fc_dropout = 0.1\n",
    "pe = None\n",
    "learn_pe = True\n",
    "kwargs = {}\n",
    "\n",
    "model = TSTPlus(c_in, c_out, seq_len, max_seq_len=max_seq_len, d_model=d_model, n_heads=n_heads,\n",
    "                d_k=d_k, d_v=d_v, d_ff=d_ff, norm=norm, dropout=dropout, activation=activation, n_layers=n_layers,\n",
    "                fc_dropout=fc_dropout, pe=pe, learn_pe=learn_pe, **kwargs).to(device)\n",
    "test_eq(model(xb).shape, [bs, c_out])\n",
    "test_eq(model[0], model.backbone)\n",
    "test_eq(model[1], model.head)\n",
    "model2 = build_ts_model(TSTPlus, c_in, c_out, seq_len, max_seq_len=max_seq_len, d_model=d_model, n_heads=n_heads,\n",
    "                           d_k=d_k, d_v=d_v, d_ff=d_ff, norm=norm, dropout=dropout, activation=activation, n_layers=n_layers,\n",
    "                           fc_dropout=fc_dropout, pe=pe, learn_pe=learn_pe, **kwargs).to(device)\n",
    "test_eq(model2(xb).shape, [bs, c_out])\n",
    "test_eq(model2[0], model2.backbone)\n",
    "test_eq(model2[1], model2.head)\n",
    "print(f'model parameters: {count_parameters(model)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_padding_mask = torch.sort(torch.randint(0, 2, (bs, max_seq_len))).values.bool().to(device)\n",
    "key_padding_mask[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 2])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model2.key_padding_mask = True\n",
    "model2.to(device)((xb, key_padding_mask)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): GELU(approximate='none')\n",
       "  (1): fastai.layers.Flatten(full=False)\n",
       "  (2): LinBnDrop(\n",
       "    (0): Dropout(p=0.1, inplace=False)\n",
       "    (1): Linear(in_features=32768, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = TSTPlus(c_in, c_out, seq_len, pre_norm=True)\n",
    "test_eq(model.to(xb.device)(xb).shape, [bs, c_out])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model parameters: 605698\n"
     ]
    }
   ],
   "source": [
    "bs = 8\n",
    "c_in = 9  # aka channels, features, variables, dimensions\n",
    "c_out = 2\n",
    "seq_len = 5000\n",
    "\n",
    "xb = torch.randn(bs, c_in, seq_len)\n",
    "\n",
    "# standardize by channel by_var based on the training set\n",
    "xb = (xb - xb.mean((0, 2), keepdim=True)) / xb.std((0, 2), keepdim=True)\n",
    "\n",
    "model = TSTPlus(c_in, c_out, seq_len, res_attention=True)\n",
    "test_eq(model.to(xb.device)(xb).shape, [bs, c_out])\n",
    "print(f'model parameters: {count_parameters(model)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model parameters: 421122\n"
     ]
    }
   ],
   "source": [
    "custom_head = partial(create_pool_head, concat_pool=True)\n",
    "model = TSTPlus(c_in, c_out, seq_len, max_seq_len=max_seq_len, d_model=d_model, n_heads=n_heads,\n",
    "            d_k=d_k, d_v=d_v, d_ff=d_ff, dropout=dropout, activation=activation, n_layers=n_layers,\n",
    "            fc_dropout=fc_dropout, pe=pe, learn_pe=learn_pe, flatten=False, custom_head=custom_head, **kwargs)\n",
    "test_eq(model.to(xb.device)(xb).shape, [bs, c_out])\n",
    "print(f'model parameters: {count_parameters(model)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model parameters: 554240\n"
     ]
    }
   ],
   "source": [
    "custom_head = partial(create_pool_plus_head, concat_pool=True)\n",
    "model = TSTPlus(c_in, c_out, seq_len, max_seq_len=max_seq_len, d_model=d_model, n_heads=n_heads,\n",
    "            d_k=d_k, d_v=d_v, d_ff=d_ff, dropout=dropout, activation=activation, n_layers=n_layers,\n",
    "            fc_dropout=fc_dropout, pe=pe, learn_pe=learn_pe, flatten=False, custom_head=custom_head, **kwargs)\n",
    "test_eq(model.to(xb.device)(xb).shape, [bs, c_out])\n",
    "print(f'model parameters: {count_parameters(model)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model parameters: 421762\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): GELU(approximate='none')\n",
       "  (1): fastai.layers.Flatten(full=False)\n",
       "  (2): LinBnDrop(\n",
       "    (0): Dropout(p=0.1, inplace=False)\n",
       "    (1): Linear(in_features=7680, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bs = 8\n",
    "c_in = 9  # aka channels, features, variables, dimensions\n",
    "c_out = 2\n",
    "seq_len = 60\n",
    "\n",
    "xb = torch.randn(bs, c_in, seq_len)\n",
    "\n",
    "# standardize by channel by_var based on the training set\n",
    "xb = (xb - xb.mean((0, 2), keepdim=True)) / xb.std((0, 2), keepdim=True)\n",
    "\n",
    "# Settings\n",
    "max_seq_len = 120\n",
    "d_model = 128\n",
    "n_heads = 16\n",
    "d_k = d_v = None # if None --> d_model // n_heads\n",
    "d_ff = 256\n",
    "dropout = 0.1\n",
    "act = \"gelu\"\n",
    "n_layers = 3\n",
    "fc_dropout = 0.1\n",
    "pe='zeros'\n",
    "learn_pe=True\n",
    "kwargs = {}\n",
    "# kwargs = dict(kernel_size=5, padding=2)\n",
    "\n",
    "model = TSTPlus(c_in, c_out, seq_len, max_seq_len=max_seq_len, d_model=d_model, n_heads=n_heads,\n",
    "            d_k=d_k, d_v=d_v, d_ff=d_ff, dropout=dropout, act=act, n_layers=n_layers,\n",
    "            fc_dropout=fc_dropout, pe=pe, learn_pe=learn_pe, **kwargs)\n",
    "test_eq(model.to(xb.device)(xb).shape, [bs, c_out])\n",
    "print(f'model parameters: {count_parameters(model)}')\n",
    "body, head = model[0], model[1]\n",
    "test_eq(body.to(xb.device)(xb).ndim, 3)\n",
    "test_eq(head.to(xb.device)(body.to(xb.device)(xb)).ndim, 2)\n",
    "head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAGzCAYAAADjbSfcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADlo0lEQVR4nOydd1gVZ/P+b3qRJqiAFaxg71hjw66x967RWLBhN8ZusIu9966JvcUWTewtmqJi74IVEJB+fn/4lby8zM0vRkg8b+ZzXVyJ85zZs2fP7p5n535mxsRgMBigKIqiKIryiWP6T++AoiiKoijKn0EnLYqiKIqiGAU6aVEURVEUxSjQSYuiKIqiKEaBTloURVEURTEKdNKiKIqiKIpRoJMWRVEURVGMAp20KIqiKIpiFOikRVEURVEUo0AnLYoCwMTEBGPHjv1Tr/Xw8EDnzp3TdX/+LGPHjoWJick/vRvpRufOneHh4ZHM9iHflaIo/1vopEX55Fi1ahVMTEyS/qytrZE/f374+fkhJCTkb9mHU6dOYezYsQgNDf1b3i+96dy5c7Jj+t/HV1EUxRgw/6d3QFEY48ePh6enJ6Kjo3HixAksXLgQ+/btw2+//QZbW9s0fa+3b9/C3PyPy+HUqVMYN24cOnfuDCcnp2SvDQoKgqmp8c33rayssGzZshR2MzOzf2Bv/jr//V0pivLvQa985ZOlbt26KF26NADgiy++gIuLC2bOnImdO3eiTZs2afpeHxJtsLKyStP3/rswNzdH+/bt/+nd+Gg0MqQo/16M73FR+ddSvXp1AMDdu3cBAPHx8ZgwYQLy5MkDKysreHh4YOTIkYiJiUnmd+HCBdSuXRuZMmWCjY0NPD090bVr12Sv+c91EmPHjsWQIUMAAJ6enkkyyr179wDIa1ru3LmDFi1awNnZGba2tihXrhz27t2b7DXHjh2DiYkJtmzZgkmTJiF79uywtrZGjRo1cOvWrWSv/emnn9CiRQvkzJkTVlZWyJEjBwYOHIi3b9/+5eP3Z3gvzZ08eRL+/v7InDkzMmTIgCZNmuD58+cpXr9//35UqVIF9vb2cHBwQJkyZbBhw4Zkr9m6dStKlSoFGxsbZMqUCe3bt8fjx49TbGvHjh0oXLgwrK2tUbhwYWzfvl3cx/9e0/J+Xc+tW7eSImOOjo7o0qULoqKikvm+ffsW/fr1Q6ZMmWBvb4/PP/8cjx8/1nUyimIkaKRFMRpu374NAHBxcQHwLvqyevVqNG/eHIMGDcLZs2cREBCAa9euJf3gPXv2DLVq1ULmzJkxfPhwODk54d69e9i2bRt9n6ZNm+LGjRvYuHEjZs2ahUyZMgEAMmfOLL4+JCQEFSpUQFRUFPr16wcXFxesXr0an3/+Ob799ls0adIk2esnT54MU1NTDB48GGFhYZg6dSratWuHs2fPJr1m69atiIqKQq9eveDi4oJz585h7ty5ePToEbZu3fqXj+GLFy9S2CwtLeHg4JDM1rdvX2TMmBFjxozBvXv3EBgYCD8/P2zevDnpNatWrULXrl1RqFAhjBgxAk5OTvj5559x4MABtG3bNuk1Xbp0QZkyZRAQEICQkBDMnj0bJ0+exM8//5wkvR08eBDNmjVDwYIFERAQgJcvX6JLly7Inj37n/5sLVu2hKenJwICAnDp0iUsW7YMWbJkwZQpU5Je07lzZ2zZsgUdOnRAuXLlcPz4cdSvX/9DDqGiKP8kBkX5xFi5cqUBgOHw4cOG58+fGx4+fGjYtGmTwcXFxWBjY2N49OiR4fLlywYAhi+++CKZ7+DBgw0ADEePHjUYDAbD9u3bDQAM58+fT/U9ARjGjBmT9O9p06YZABju3r2b4rW5cuUydOrUKenfAwYMMAAw/PTTT0m2N2/eGDw9PQ0eHh6GhIQEg8FgMPzwww8GAAZvb29DTExM0mtnz55tAGD49ddfk2xRUVEp3jcgIMBgYmJiuH//fpJtzJgxhj9zGXfq1MkAQPyrXbt20uveH3tfX19DYmJikn3gwIEGMzMzQ2hoqMFgMBhCQ0MN9vb2Bh8fH8Pbt2+Tvdd7v9jYWEOWLFkMhQsXTvaaPXv2GAAYRo8enWQrXry4wd3dPWn7BoPBcPDgQQMAQ65cuZJt/7+/q/fHoGvXrsle16RJE4OLi0vSvy9evGgAYBgwYECy13Xu3DnFNhVF+TRReUj5ZPH19UXmzJmRI0cOtG7dGnZ2dti+fTuyZcuGffv2AQD8/f2T+QwaNAgAkqSZ90/ye/bsQVxcXLrs5759+1C2bFlUqlQpyWZnZ4cePXrg3r17uHr1arLXd+nSBZaWlkn/rly5MoB3EtN7bGxskv4/MjISL168QIUKFWAwGPDzzz//pf20trbGoUOHUvxNnjw5xWt79OiRLJW6cuXKSEhIwP379wEAhw4dwps3bzB8+PAUa0ze+124cAHPnj1D7969k72mfv368PLySvqOnj59isuXL6NTp05wdHRMel3NmjVRsGDBP/35evbsmezflStXxsuXLxEeHg4AOHDgAACgd+/eyV7Xt2/fP/0eiqL8s6g8pHyyzJ8/H/nz54e5uTlcXV1RoECBpKyd+/fvw9TUFHnz5k3m4+bmBicnp6Qf1ypVqqBZs2YYN24cZs2ahapVq6Jx48Zo27Ztmi2ovX//Pnx8fFLYvb29k8YLFy6cZM+ZM2ey12XMmBEA8Pr16yTbgwcPMHr0aOzatSuZHQDCwsL+0n6amZnB19f3T732/7eP76W6//xc/83776BAgQIpxry8vHDixIlkr8uXL1+K1xUoUACXLl366H12cHBIOmc8PT2Tve6/zyFFUT5ddNKifLKULVs2KXuI8f8rrGZiYoJvv/0WZ86cwe7du/H999+ja9eumDFjBs6cOQM7O7u03OU/BUsxNhgMAICEhATUrFkTr169wrBhw+Dl5YUMGTLg8ePH6Ny5MxITE//xffwUMcZ9VhTlw1B5SDFKcuXKhcTERNy8eTOZPSQkBKGhociVK1cye7ly5TBp0iRcuHAB69evx++//45NmzbR7X9IldlcuXIhKCgohf369etJ4x/Cr7/+ihs3bmDGjBkYNmwYGjVqBF9fX2TNmvWDtpOe5MmTBwDw22+/0de8/9zSsQkKCkoaf//f//4ume9f5f058z777D3/nbmlKMqni05aFKOkXr16AIDAwMBk9pkzZwJAUkbI69evUzxpFy9eHABSpEb/JxkyZACAP1URt169ejh37hxOnz6dZIuMjMSSJUvg4eHxQesygD8iBv+53waDAbNnz/6g7aQntWrVgr29PQICAhAdHZ1s7P1+ly5dGlmyZMGiRYuSHev9+/fj2rVrSd+Ru7s7ihcvjtWrVyeTvg4dOpRiPdDHULt2bQDAggULktnnzp2bZu+hKEr6ovKQYpQUK1YMnTp1wpIlSxAaGooqVarg3LlzWL16NRo3boxq1aoBAFavXo0FCxagSZMmyJMnD968eYOlS5fCwcEhaeIjUapUKQDAV199hdatW8PCwgINGzZMmsz8J8OHD8fGjRtRt25d9OvXD87Ozli9ejXu3r2L77777oOr53p5eSFPnjwYPHgwHj9+DAcHB3z33Xcp1rZ8KPHx8Vi3bp041qRJE/GzMRwcHDBr1ix88cUXKFOmDNq2bYuMGTPiypUriIqKwurVq2FhYYEpU6agS5cuqFKlCtq0aZOU8uzh4YGBAwcmbS8gIAD169dHpUqV0LVrV7x69Qpz585FoUKFEBER8VGf+z2lSpVCs2bNEBgYiJcvXyalPN+4cQPAh0XXFEX5Z9BJi2K0LFu2DLlz58aqVauwfft2uLm5YcSIERgzZkzSa95PZjZt2oSQkBA4OjqibNmyWL9+fYoFmf9JmTJlMGHCBCxatAgHDhxIkhWkH3ZXV1ecOnUKw4YNw9y5cxEdHY2iRYti9+7df6kGiIWFBXbv3o1+/fohICAA1tbWaNKkCfz8/FCsWLEP3t57YmJi0KFDB3GMfbbU6NatG7JkyYLJkydjwoQJsLCwgJeXV7LJSOfOnWFra4vJkydj2LBhSYXqpkyZkqw9Qp06dbB161aMGjUKI0aMQJ48ebBy5Urs3LkTx44d+ysfV2TNmjVwc3PDxo0bsX37dvj6+mLz5s0oUKCAVtpVFCPAxKCr1BRF+Rdz+fJllChRAuvWrUO7du3+6d1RFCUVdE2Loij/GqQ2CIGBgTA1NcVnn332D+yRoigfgspDiqL8a5g6dSouXryIatWqwdzcHPv378f+/fvRo0cP5MiR45/ePUVR/j+oPKQoyr+GQ4cOYdy4cbh69SoiIiKQM2dOdOjQAV999RXMzfUZTlE+dXTSoiiKoiiKUaBrWhRFURRFMQp00qIoiqIoilFglCJuYmIinjx5Ant7ey0IpSiKoqSKwWDAmzdvkDVr1g8u9vghREdHIzY29qO3Y2lpqXWDCEY5aXny5Imu9FcURVE+iIcPHyJ79uzpsu3o6Gh45rJD8LOEj96Wm5sb7t69qxMXAaOctNjb2wMAlvxUEDZ2KTu7jvmloeiXaw5fcxw8mHfOjXgqdwK+WH8Z9Sn7bQ/R7nKZ78Oz6vF0jGF135KORWePE+3HfRdSn5WhRenYiXI2ov1Ny7LUx6zNMzpmYiIfi9G591AfaxP5GPVc25P7vKRDqNX1lGiPM8gdgwHg0EMv0V456x3qc2x3CToWVyhStOcJSFlT5D1hhZxFe4IVjzxOGLmcjvU80VG02/3Gz689/ebQscEP64r2iz/noT65Cz4W7U/DHalP9Rw36Nj3t71Fe65u16iPWXa5KeWDb3g38FlFttCxVwlyleGv97WmPi5eL/j2fs0s2k+2WSDaAaDagt6i3e4pvxc5/cZbRoROkH+Uu3jI1xIAnA3PLdqP38xHffIs4fdDw1h5/15vlR9mE2Kj8dvG8Um/HelBbGwsgp8l4O7FXHCw/+vRnPA3ifAsdR+xsbE6aREwyknLe0nIxs4MtvYpf1zMbOUv2tycX6Rmtnx2bGojby+1E9OUnGzmFnwfTG0+fNJiZs1/VExt5B9e+1T22zrego6Zm8hj5hb8wjLLYEXH2KQlg/CdvsfaRJ5cmlmlsg/8EMHKTv5MpqlMWsxs5c9kSbYFpL5/CeTcMzfjE2l6zC35pCW148rOcTMrfvBSO48sMsh+7H0AwJycK2bx/Bxi3x8AmLL7ADmPAcDMlOwD+c6B1I9rdII8xu4PAD8Oqfmldi9i515q9yJzM74P5hnk89XGjv+cWCaS84F8RwBgbp7KpIWdK5ap/8j/HcsJHOxNP2rSoqSOUU5a3jPycCvxJvhltSPi64/FleEb+9GJDnmtkp/MLBrzw2dC5kCRrvxkLpbnIR2zNpMv4NDeUdRnw82jor361MHUxyqU38hccsr75/RbKPW5+ZI/JZuYyj/Kt2OzUJ8pm5qJds/t/OnUJIF/pp8elRftFhH8hll71mXR/u250tTHmv+uIZ/bc9Gea+0r6lM4wxnRvmi5HGUEgEgDn4CMrrBbtG+e50t9Om5tTscQJ0f5CmTmn+lmZ/kpOcdh/l3YTuHrB74vP1+0d6/Yl/rUXXhMtB9syHs+dRzenY557JTtuaL4fsf95ELH8v0eLNqftJOPNwDk3CVHO3Ote0R9fn0lR5wAIOKQm2hfW8eH+iTOkn2yp3Jd5JwbRMcmuh8U7ZXyyfe2xOi/r7JHgiERqdxy/pS/wjHqSYuiKIqifEokwoBE/PVZy8f4/hsw6kmLmUs0TG1T2veMqSG+/vCeeXRbZWb2o2MJr2T9tND8XtQn33fy03OWVSHU5/ShwnTMroS8MKPYMXkdAACEJcrhHrvHfCbvcIFvz3Ob/JnOBPPuwCYR/L1M7sh+mzvx7svf35wq2mc1rEp9bjSU1wEAwIx5G0T76CpNqU+CQQ4x2zzgl1PGG/w4JBzMJNrfBPIo2rcD64j27E/5WoS5a3lvnXsLXUV7zt/4mpFbY3hkKe+cW6L95VR+Q56Qb7NoX7n9c+pT1o6vI+p7p4VoT0gl7LW3Z1XRfnM4l5RMLLm0/LZPuGhP/Fb+zgEgol4EHbN1iRHtfTz5dzvp9kbRPvqzJtRn2vGtdGyva3HRnsear1/belvev2vDeSTWrnlGOtYpk7xmcMaWNaI96k0C2o6mm0tTEpGIj4mVfJz3/z4qvCmKoiiKYhQYdaRFURRFUT4lEgwGJHxEd5yP8f03YJS9h8LDw+Ho6Ihdv+QRV+53Pyunb9ra8MVvdpsc6FhIWVkOMI3hK9Ez/SKH+F578eBWrBMPC95usVi0/xrL02LDE+UV9tEGHuqeXpgvVn7RTk7bDa8pp+wCwC+VeJpt6XOdRHvOvqHUB4nkGFnyRabXB7rTMYeb8vfRpMcx6rN7dlXRnumyLAUAgEkclxBujZT3PeN+Qfv8PwZ+JUspG5/y9PP4jvx7jyooL5RsO3Mv9Vk4rzEdK9L+d9GeLwOXEAY4XxbttX9rS31CI+U0fACIvSunt2b9kX8X1rvOiXbLY/wcerCDy5lus+UF00+GlqM+EXn5otpcu+R7zleBK6nPtM7tRXvX5WSVMIDvX3GpemXOn0R73bzyonYAeLU1m2i3NOffRU57LnX+vF9OZ492k7eX+DYaDwd9jbCwMDg48Hv9x/D+d+n+9awfnfKcy+tJuu6rMaPykKIoiqIoRoHKQ4qiKIqSRiTCgATNHko3jHrS8vWMbmIxobVfzRVf33avXBkSACxSCec5kgSKqUOWUJ8vLeXaDQ75eZ2KUfkP0bFyw+WKr3YPueR1u42cJZGTF5zFw0A+VmDgZdHu8mte6rO+GC+Z/faeHPocf2IV9Wl3vptotzvIK5bmLszr3ziXkuW1jOZc8npVNVq0vyzL5RzvabyOzK7ysoTW/givpzN6m1xRtUQlnu1zZwEPNdvPlm+UZqSYHwA4X5UzWQDg95ey3PTTlQLUZ9e5qqL9RUm+D96Tea2RwJOypNp/nJx5BQAJFYqL9sSWPKvuzWR+DZr0l2WgiHxcAlpTnVfa7nVHzlgceKUl9bHzkAuu1bbln+lGtPz9AYDPz3J9nqi+PEvPfh0pCplKduGNLHwfokvKMlCRwvdFe1xkLPhdIG3RlOf0ReUhRVEURVGMAqOOtCiKoijKp4RmD6UvRp091ORQF7HHyeuBcgnqDmv30W1+fVAuRAUAtk/lgFTWH3nxr0QLWZopNO1X6rP3eCk6ZppNfq98o95Qn9hsTqL9fh3enyPf3Lt07MZ0OVyb2hlkeMF7mPTz/V60r14gN9sDgNcl5LC6iQUPM5um0sPHc6mcjRGalx+jF+XkfShXkBc6K+PEj+vaxbJc4fIrl1/ufSF/pvNVeOO8gOcV6djFl7KMd/8XOesDAA43n0bHvg0vLtob2V+hPp1GyHKY4+9h1OdJDSc6lvmKfPwsXsvyHgBEkCaVtuO4tGb+Dc+Ier46l2h/m5lnHrrUfELHouPkDDCLZXIDTQAYOnWdaB9ySW6JAQC5ZvL9MyEX/Iuv+fn6Nkbe7xM+S6lP65a8eGeUm3xficgq33cTYqPx++KRf0v20PVrrqn25fr/8eZNIry8QzR7iKDykKIoiqIoRoHKQ4qiKIqSRiR8ZPbQx/j+GzDqScvlR1nF1uZ5bz0QX//1Id6V9k4zOdMAALo9lMPql8rxzJisA+VQ6b5jXAJyPc9PVoeecvZJgjMPC49dKWel9FrQh/oY3vC+J/GR8umSYy8P2L114WObz8qyiBlPwsHhWoGivWngEOqTwBUqmEfIBeEGDOWFtyZuaiXaz0Xloz5fNDhOxxoNlmWWN4n88owzyGHwiksGUZ+1XWfTsd86yVk95s25TMAkIADYPkHuDn2+rwf1ydVHznwKb8tPiEy/8DHXCbJcNzzrfurTa8gA0f6kEj+P+7lepmPriOz2qjDvfxS+nXdY9uu3TbTnm857mk1q00G0t196nvqcvsPvbbf7yed5dVeeuXZ2RUnRHlSSF4XctGUhHdsXKe/fqOOy5JX4lncKT2sSDPjILs9pty//ixj1pEVRFEVRPiUS/+/vY/wVzgevafnxxx/RsGFDZM2aFSYmJtixY0fSWFxcHIYNG4YiRYogQ4YMyJo1Kzp27IgnT5IvLHv16hXatWsHBwcHODk5oVu3boiI4E/4iqIoiqIoHxxpiYyMRLFixdC1a1c0bdo02VhUVBQuXbqEr7/+GsWKFcPr16/Rv39/fP7557hw4ULS69q1a4enT5/i0KFDiIuLQ5cuXdCjRw9s2LDhg/Ylz+hXMDdNGft/3FHuS2H2lsfdCs3nK9UL15XDnlG/cmlmzfHpor3jLS5RNa5/mY5Nu1JTtB/8dj71qX1aloEqtfiF+gRvcaJjpm/lkLaFH892iI3l2kyGyXJBuEEr+XlQa7ssf3Tp/AP12f9NFTrWe/N20T6nKy/WNX6ZvH8j9rShPjPKVKZjT1e5ivaM8+XeOQAwbbGcJZT5Cu/lMsiPy4LBo+SMmlwtT1Ef02b8mfBZY3l7+z14ZcPK0/1F+5sh/DMVWMqz507/nF+0N7os2wEAVeV7hPcMfo4vq8KzstpPljPkXsTx73ZIq4t0rNyCgaLdvQYvnWbxuyyTNXL4mfoUOPGUjvlYy9dMl64D+D5klY/rhLK1qc+16XLmFQAU8ZAL4/WpcFS0R0fEYwzdWtqSCBMkgMuqf8Zf4XzwpKVu3bqoW1dOSXV0dMShQ8mrus6bNw9ly5bFgwcPkDNnTly7dg0HDhzA+fPnUbp0aQDA3LlzUa9ePUyfPh1Zs3I9V1EURVE+ZRIN7/4+xl/hpHvKc1hYGExMTODk5AQAOH36NJycnJImLADg6+sLU1NTnD17VtxGTEwMwsPDk/0piqIoivLvIl0X4kZHR2PYsGFo06ZNUpGc4OBgZMmSJflOmJvD2dkZwcHB4nYCAgIwbty4FHaTxYkwzZAydGy5Rp6quvzG+330XriFjk2cLbd2z/kbL1LVcXYjecCeyyVTexEfAPkDZInq5UW+Pc+2v4n2YBcua93qn5OOWbjJ644sh/ECSCZOfP/2bJQztgodk/s2AUCDipdEewnbe9TnQAKXh+YX8BLthx6uoj71KzcW7XU2y/sGALl/ek7HKtvKPad65u5HfYZ3+lK0v+zP14blcXlJxx7ck4vIGSoVpz41MyyiY0tvyJlhrbpVpz4mPWR7vnX8Ors1nGef2F6R5cyNPWdSn2cJsmQ54D7ZOQCHivIie48T5P3rOaE/9dlYk2cY5pkhn2NezXh2zA1nuShk0y2y1AQA+SbI9w4AGDlalkE9Yvn3ZNomVLTH3+DFC70nvKZjgw/KslvgY1lGj4vk/aHSmoSPlIc+xvffQLpFWuLi4tCyZUsYDAYsXMhT1/4MI0aMQFhYWNLfw4d/V+srRVEURfnzvJ+0fMyfwkmXSMv7Ccv9+/dx9OjRZKWI3dzc8OxZ8rLX8fHxePXqFdzc5CcCKysrWFmlUmxDURRFUZT/edJ80vJ+wnLz5k388MMPcHFxSTZevnx5hIaG4uLFiyhV6l0Y9OjRo0hMTISPj88HvdeTXblgZpWyuFx8Jvn1L0rwjzt0X1s65nFdDi3e78mzGgB5QfGJirw3zKLXZejYqS1yyHikB/e5P0E+ns7X+Eovj1Fn6FivG7JENTNHO+rzqAZ/avj6WVnRnu+L69Sn+e9yQayuZztRn9rDeJbEWUf5GNVsW4z6NNtzULTvLMWltTumfIH5oQIVRLulF/+e3gyTs2YcTFLxSSWT63INOQutokM36tNoL5c4jnaZKton161FfRIj5KKQUXW5BOQcz4u0uSyU+z1NbSRLVwAQPDy3aDcpLZoBAE2HyT2TAGDE+DWi/cfxgdSn6lf8uDodzSDajy+XiwMCgK2PnOVlyMblHJMs5CYK4GrbeaK98WLev62E2z3R3mgDz5RKTEUIWBIiS75vRspyU3w8/6xpTaLBBImGj8ge+gjffwMfPGmJiIjArVu3kv599+5dXL58Gc7OznB3d0fz5s1x6dIl7NmzBwkJCUnrVJydnWFpaQlvb2/UqVMH3bt3x6JFixAXFwc/Pz+0bt1aM4cURVEUo0bXtKQvHzxpuXDhAqpVq5b0b3//d7UVOnXqhLFjx2LXrl0AgOLFiyfz++GHH1C1alUAwPr16+Hn54caNWrA1NQUzZo1w5w5c/7iR1AURVEU5d+AicFA+ox/wrxvAf7dlfzIYJ8yPDw0UM4+cb7GV5BHucqt0wEguIosA+Vfxbdn/kRe+R5W2p36tB2/l47NulJDtHss4iHU5yVSSmcAkG0v71Oy7dhmOvZ5M1kqeDMmkvpYzueZShkuywWiHjfjRaXMo2R7lLwcCgCQYyKXvHrcuCXaA6bLGWMA4NJKljFszXl2Wis33udl7tdyITvHX15Rn9elXER7zp43qc+vh3hRtSwX5eyTGfN48cJ7cfI+AMC08bJkuHaiXHQRAAbUkiW+WHeenXa7A5eHMjjLJ4vLClliAQCrgXIRudip/Lo1Hcyvp2+95Oup3GreI6qSLy/+mMtGPid2LqxKfcwbyJlr6wqvoj592vvRsVcFbUS72ec8Q+75o4yi3XsSL9o35wS/FzWZLfcaMycqUEJsNH5bMhJhYWHJ1limJe9/l47+lgN29n89xyXiTSKqF36YrvtqzGjvIUVRFEVJIwwfuabFoGtaUsWoJy3jZnWGmWXKaELfQXInVEcz8pgOYEU1XmY9pLK8uGveRv4UOvJhY9EeOYWXPp/5fQM61r/2PtG+qFJ96rP8i7nytmq2pj5ee3vTsezZ5KcH+5QldJIw+/0aH8wql6/P1uQedSnkKNfy2XWzMPV59FU5OjbkoLyQOf/PvDx83yFHRHu/vXwxcOh+vkg3xk+Oyl1/yUu9m5IgTAfnIOrz+Pe8dCzYh3TwNuPRxJFtmtCxsDryjXdzGF/RWn7r76J9xc/yQmUAMKRSfiP7RHkf8i++TH1Gux0T7R0vfk591nntpmPt6nYR7Xni5a7tAFC8CS/psOGbeqJ9fwCvFdOxSU/R3qos74xuKndCAcCjmianM1OffNXl6OT1wbybtHUqi8oNlcJEe/hdOTKRGP33CQq6piV9SfeKuIqiKIqiKGmBUUdaFEVRFOVTIsFgigTDX48HJBjdKtO/F6OetGTa8DPMTVIuoJ1aS64F4b5KXpgKAC/m8sWkCJMX4racwcOrhdtcFe1WL2KoT4FAvvByfqQsA3VpI5eAB4Cv7zQW7XZWfB/scsvyCwAsmbVRtHcYxhcVrt1ygI4tePGZaL/WkcsYO9p5iHYHuZEtACBz2/t0zKS/HE5O+JXLLH0PdxDtjp6h1Od+a7k8PABYRsn1U0xf88XhidayzLizKy+T/9mi03Ts1Ci5Xk2NN/wcz3mbL/q99IW8qLzMvAF8e3PlBaju9flxsNvMF1m/aS7LgvsPc4nqVRVbecCG3ztWhhWiY49rygvRN/fnC5LXv/6welUA0Kr7ADo2Zsty0T5gjiwbAYD7Ub6o1nqpLM3c3civ24RJshTsFcSlsAnleE2ftSVWiPamIX1Fe6JJajW10pZEmKRaY+b/76+zltRQeUhRFEVRFKPAqCMtiqIoivIpoQtx0xejnrTkO5wIK7uUYfKgX+Sy31bP39JtWR50pGMJpKJ1ZAUuKS3MIXch/XYlzyJxMecdev3PyyWyK9jKdUYA4PhAOQzebqtchh4AVvjxjJBvZxUX7QsCZlOf3i15NlLUODlD52kXXtslTwk5C+F2Tp65kLk2D3UHTcsh2nNvK059PL+VpZkBi3gWSf/ved0XPJClo1LV5bYJAGBtJteE+Qly12oACJ3Fs3AynZPPo2el8lEfOPDspqoj5VL00cV46HvKb4dFe8vVRanP6zH8M3mueyran1TPItoB4NqKgqL92KlZ1KeeH+/G/eZzOb2p/k5/6uNymf9oOT6Spd1nxbl8NaWF3KLEyZ13ho6cy2sOjc0uZzJ+vZjLWkGLS4r2C3W2Up9T0fyabn1ersVlak/2m1wv6cHHr2lReSg1VB5SFEVRFMUoMOpIi6IoiqJ8SrxbiPsRDRNVHkoVoy7jX67+BJhbpAyL2uy5IPoZEvgK8pvzeGgz/1pZVrrXgGeEsPMu114uKd1sx0O8zlfkcuW2L/hnmjRjiWif2J4XQXs8mIdRl5WQO9a2PcqzEMZV2kHH1nWWC2VFZZXLhAOA28Dbov1BmBP1KejCy6yf+FHO/Mgz4hz1ubG8hGjPeJZ3I3bbxmW8a2M95YFUrswFtVeJ9gwmvNraV7ca07Fn5+Qy9Vl/4ueD9SnejduESEdvC/GmqBHZ5Cwh69e8IKNZDB9bvViWdC7F8J4Pi9rJ8ujTkfw6Mz3qRMd699oh2tc84AUPo7fy/SvR44po/3kJ70pu/lY+kUKqc3loc/WFdGx0446iPawQl9hjHOUbYiLvwoCjw2fQsW/f5BHtC27KGYkJUTH4vdW0v6WM/9YrXrAV2sv8WaLeJKBFsetaxp+g8pCiKIqiKEaBTloURVEUJY14vxD3Y/7+CvPnz4eHhwesra3h4+ODc+d4tBgAtm7dCi8vL1hbW6NIkSLYty/5Autt27ahVq1acHFxgYmJCS5fvpxiG1WrVoWJiUmyv549eeQ9LTDqNS1xGUyRaJnyC364oJT4eu+RsrQAAJk9eWG3Nd+uEu2tu8kZEgBgdUIuLmeag4fHB1Y/Rse2HK0j2t90kQs9AcCXl+SMldGrdlGfwImt6NiEgY1Fe45iXIOdc1rOegIAR1s5E+KVF79ozd7KHXr98h6jPhva1qZjK7YuEu29XvWiPhlJPbNGvfk+XGzNs8Y25Fwg2jtu4Z12ZzdtJtrjHeVCdQBgbsMv98Qusmz5uigvRBhXsggdi3GWJYmhDXZSHyaZPLpH0vcA5MzNM8NqbJEL441osJ36vCguy1oR97kMZcmbXePwSzkbKUM9XvAwojeXh65NlntsRXB1CE4kCS3PGi55tUzgWX9n98iyW81Uim3+PFTu01Y3m3yvBoAKmXnRyhg3WdrKeki+d8THkfbP6UAiTP/24nKbN2+Gv78/Fi1aBB8fHwQGBqJ27doICgpCliwps+VOnTqFNm3aICAgAA0aNMCGDRvQuHFjXLp0CYULvzvHIiMjUalSJbRs2RLdu8vZWgDQvXt3jB8/PunftrakQGMaYdSTFkVRFEX5lEgwmCDhIzo1/xXfmTNnonv37ujS5V2DzkWLFmHv3r1YsWIFhg8fnuL1s2fPRp06dTBkyLuJ5oQJE3Do0CHMmzcPixa9e5Dr0OFd5e979+6l+t62trZwc+MT7bRG5SFFURRF+cQIDw9P9hcTI0c9Y2NjcfHiRfj6+ibZTE1N4evri9On5dYdp0+fTvZ6AKhduzZ9fWqsX78emTJlQuHChTFixAhERUV98DY+BKOOtDwvZYCpTcpQWsaf5Y9V6dgjuq012wrQsUpv5FDplZVyWB8AZryU47VRiTx7aM8X1ehYxflnRXtOq5fU57sncpbL8ocVqY/TBjnzCgCsf8go2h1MuewWWp1/3tAW8v5l+pVnNTxykbNcJqUiQ7lM4tlD12Pk7e3pPZX6XCbZJyzzBAAmbZF7pQDAjlC58JZzkRfUp/82WeLre1YuJAYA5pY8RJ4rY6ho/64AL/5Vd8MAOua4UM4s+nYIL+xmZyv3vcrG1RzEJfAsjXhH+TyaebUG9XF4I8tAppm5TJa/uFzELjUSKnM9p2Kni3Rs32n5mtnakBd47DVOLn5nGSIXdwQAkwRe4DGjqZzlGJ9KMmW1nl+K9g0PZlKfbp78u32zR5Zbn5WWexwlRpsCO/j+pSUJMEXCR8QDEv5PHsqRI3nhyzFjxmDs2LEpXv/ixQskJCTA1TX5Z3d1dcX16/J1GBwcLL4+OJj3npNo27YtcuXKhaxZs+KXX37BsGHDEBQUhG3btn3Qdj4Eo560KIqiKMqnRKLBFIkfURE38f+qkDx8+DBZyrOVFV+v9k/Ro0ePpP8vUqQI3N3dUaNGDdy+fRt58shp6R+LykOKoiiK8onh4OCQ7I9NWjJlygQzMzOEhCSPKIeEhNC1Jm5ubh/0+j+Lj8+7eme3bvG6VB+LUUdanK6ZwkzIHoojLVH8nX+n29p1ozode5FfXhj12WXeTyb6uJzxkPVHLpfc4clIeLpO7rGSYw3vTxNZJ5tofyUnIAAAbPvIvXgAwGyDbM/wlGchPF7Gi5OZW8raZ1w0Py29x8vZInen8Nj0fC+y4wD6+suh81ltuS5rdUw+wWKHhVOf3OZc8pqQ5TfRfuQplyzjDPIxSnjNC9y5HuNPareryyv+6ywbQH2ajpJ7BQHA9929RXvUEt4byemS/N0+us/Tc6yf8nOlxedymte+zbyw24kZcpZLja49RDsABLuR4oDgRdWy/c6vW7NUskeyH5XHguvyImTl+8hy09kWuahPlk38ebbRkCqiPX4EdcHDprLs9jCeF5K8s07OvAIA0wtyFmHPJgdEe3REPL4ew/cvLUkreejPYmlpiVKlSuHIkSNo3LgxACAxMRFHjhyBn5+cgVi+fHkcOXIEAwYMSLIdOnQI5cuX/6u7DQBJadHu7rLsnhYY9aRFURRFUT4lEvHXMoD+0/9D8ff3R6dOnVC6dGmULVsWgYGBiIyMTMom6tixI7Jly4aAgAAAQP/+/VGlShXMmDED9evXx6ZNm3DhwgUsWfJHFfVXr17hwYMHePLkCQAgKCgIwLsojZubG27fvo0NGzagXr16cHFxwS+//IKBAwfis88+Q9GivMnpx6KTFkVRFEUxYlq1aoXnz59j9OjRCA4ORvHixXHgwIGkxbYPHjyAqekf0Z8KFSpgw4YNGDVqFEaOHIl8+fJhx44dSTVaAGDXrl1Jkx4AaN26NYA/FgRbWlri8OHDSROkHDlyoFmzZhg1alS6flaj7j1UsNc3MLNKuZI92155BfTV4TzM7Jg5go5NK/ytvB+JPLQ5/56cCRQ/n2uGFn48C8G6jSxX3PHLT32GtJJXcM9e0pT6dOomh1cB4P5bWfK6XoZLH2YZeT+S+71kCcGkFC+YZ7gob8+j5j3qc+Mpz1jJvk6WUx5V45kLdvlfi3brLXJ2FQA43uSyYAIp+hYzUn4fAIhdK59Hdo9476HME+/RsdvL5PMoQzD/bkNKy72CAMCspPwdujlwCe3epeyifV/L6dSn3djBdMyi1TPR/nW+PdTHxypUtJfcL8uIAFDSixeKe/WNLMEUnSD3EAKAm1W5xDfil5OiPZrIhQBw5a28D1amXLqdeaoWHSv4jSzj7fjpO+rzeb0Oov3hGB6RiL/K7x1OJeV9iP4+s2hPiInG1YUj/5beQwsvlYGN3V+PB7yNiEevkue19xBBIy2KoiiKkkZ8TCn+9/4KR4+OoiiKoihGgVFHWt66AlKdo6Bxclix4BBeXC6kPs8AmG5PeteM5HJT/jk3Rfvt19wn5IAcHgeAHDYPRLtlKHVB4DJZBurWbT/1WbG8Lh3z675DtO+d3oj65NrPQ9BHek4T7Q0m8h4mWdb/ItofR/CFX/m3y8cOAIIC5HCy52K+389Ky4W3HDedpz5vmvEeK8FyYhiuFuKF3Yrlk+WKDME83G5qwpf4ZfpWzmDqceln6uNrwwsbBsXLz0NXonl22je/yOd/00s8c+fKJF7gsd1dX9E+4asuoh0AKg+TM468FvJssvBpPCvrSSVZQrNtyIu3mVjxc6/LLrlI2+rPF1Kfs6Hyve0zZ57BZGrFMwLjXeX7a+MyDahP2HJZtoy6y++H+fbxY/7kjXzdNuwiy2cxEXG4yg9RmpIIEyTiYxbi/nXffwNGPWlRFEVRlE8JlYfSF6NeiMsWPG1q8Jnod6N7KiXEH/DZ7ZYhckSgn5f8JAcA4Y3kMt2OV3g3aZNY/oRlsJEX5/XawRcVBozuKNqd9sodqAHg1kheG2FlC/mpNjiBL5gbdYVHYbIulp9QX/Xli6ITj8lPqFav+WkcmZV/t61aHRPth8bJ5xAA9PxGjoCsK8IrQJo68WOUmF0+L6Oz8G6piZbyZ8o05B71ubsxLx1zeCgvuH3oy2+gtk/4mFdDOdIYXplHZx6OluunON3k320Zf17y/tgj+fOOK8S7nP8c5SHady3n50OmX3h7BMvH8oLke63kcvMAEOP9lo7l73NXtL9oIi9qB4A1Y2eI9jEPP6c+b+rze9HzFoVEe2qLti0i5LE7TfmiY8cgfn65738i2t/mlZMF4uOjcfLI2L9lIe70C5U+eiHu4NIndCEuQad0iqIoiqIYBSoPKYqiKEoakWgwQeLHFJf7CN9/A0Y9aZm2rQnMrFOuxM3oI4eTj7SWZR4A6NaR12Fo+5u8cO/ldF6XA3ZyePVZSb7wLJUuAxg6ar1oPxrGw8LBNeV9iMosh3cBwHMnX/z2zQI5nHxvZiryUJF9dKzlKrmOxi9xfMFohwtyrwP3H7mktHAM77DMuDKAL4peX1qW0OLLcfklcgTvqHugyHLR3qZKG+pjyCB32n38hn8XXfz28n1oKHeaLjqEnw+PL+emY1Ed5TLriVX4Qtzan58T7bt/Kk19rodzyTfb1/J5NHVqHepTye2OaA8vwyWgDl8eo2PzD8v1TjZ9Pof6fP+mCB07WFWWqV6U5tfMkLvNRHu/HLwNg98S3i3c8pJsf5OT/5ys7SBLyzOfkCQHAP4Nv6djDwbIMvHXa+XWKgkxicARurk0JfEjy/gnqgCSKnp0FEVRFEUxCow60qIoiqIonxKJBlMkfkQG0Mf4/hsw6kmLbdHXMLNNmYES/VwOHdZbMJRuyzoffx/XfnI59cLrr1GfkO5Z5QETHm43mHEtc9YIOVybYMV9lo5fKtpnTm5Mffru203HHsbK0ta29rxD9vhmrejY7FuyjGf3mGchWJHv6ekoXlci8GlNOvayqywvFN7AW6tvH+0j2vOO4aXZX/5cnI7V+NZftEdN5SXvY+/InaZNL/PzITEXvxkm2sktKRZ6rqM+lYryEvrePeRr5vx+cl0AuPVzCdFuYs2lj8cHc9IxVze5NkhoZAz1uTRY3gfTL/j5teCy3PUYAK43l7tGP0vkctPumVXpWEQh+fstUliWtQAgk7UsnS54zK/broVO0bE+FeWaPlsieNfoNtv6ivZutY5yn+2yDwAcbS5L/dl/kDOv4uOjwa/otCUBJkj4iForH+P7b0CndIqiKIqiGAVGHWlRFEVRlE8JlYfSF6OetCwptA529im/4Ogi8scyAw8zj3vACy1V7H9btF+L5B2bH9aTJaocu15Qn/Lr5LArAPwwtKJof9KAF96aWa6qaM+yW87aAYAJN3kpbqeusrQVv5Z3ZV7gsYmO9TgpF7/rXZZnuax5KBcge/zKifq8ai1LKQBgEidn9Zimcq589tmvon35rdPUp15tLmNcH2gn2h2P8cJSMwbIGUf3YuXy5gAw7SD/bq0+l2+UXRrLZeMBIN903h7hWXVZmrHqTl1gWlw+v3KO5nLh2xz8GFkclVsQDJ3L23kkzpdD85Vt5HsAAMx6VoOOlZgrSxw59/Iik5li5Q7GADB4t5zxM+UGz8KJ/0LO5Mq2Ppj6bJnHJdVL7WUZ6JucO6nPguvycf1ptZy1BgCZeWcONA2Spf5CU+UUzNjIWIB/TWlKAj5O4uFCpAKoPKQoiqIoipFg1JEWRVEURfmUUHkofTHqScvXTdvC3Cxl9lCig1x4y2XWQ7qt30/xvjGvT8rh0AfNeSCvShNZ6qnelWccrfPihbfKXJJ7rJgM592DPffL0sf+k3KGBADkH0IqRwEwPyRLXkUc+HF1MuN9VK7XkLObniZwn/EPG4p2r8BI6vOiKi8Ul+mYLBWYmnDZrapTkGif+MKL+iCVFl+GRDmUnEpTZtoj57s5PAZuKC9LNgAQHy13I773OZdfso+RfQCgxKmnot08TO6dAwCPvpO7EYcV5gfCtvtjOtYh8J5oX+YvF1sDgPt15e/Ce5rc6wYAYGZGhxKmytdg5kby8QGA64t5/69VFeVCe4ktedHK637y8btxnBfmy72IZw9FtJYzwNqO5tlkJyfJxfRqDPCjPlGZucTi00bO1Lv+TWHRHh/Hs7XSGm2YmL4Y9aRFURRFUT4lDDBB4kesaTFoynOq6JROURRFURSjwKgjLfEutoB5Sino69WrxNdfjuYZHM/KyBkcAIADckaGSybe7+b4JbknUIVqvMTRvHs/0bHauwaJ9nzhXEq5W08O7VvM5wXu7q7nEoftFvkYRTXlMsGozGfpWPlxch+hYYM3UJ9fasnFug5X5uFxN3Oe3VTAQpZMWrfoSX06bpKzhOZOaU59UIYPFc0nSyY3H/LePptWyDJQVD4uQ3nN4udr5iWyXFHeiWfNfHuMZ6x8e0WWIPuX4cXE3nS/J9p/6ikX8wOQSo4XEHhLPkZZfuPSjH0BWaKNy8HPr1fetnQs9rG8h1+U/JH65JvA+3V12y1nOTbswbdXyU6WM3vt7kZ9UKE4HcpiLReye5SRRwhKLJZ7u52ZNZP61B4+kI49qin/dNkWIBmO8SoP/a9g1JMWRVEURfmU0C7P6YtO6RRFURRFMQqMOtJice8ZzE1TZg/ltpBX7I+/y6sVxczlPVHyTZELFr18xrNSvGe/FO1T3jaiPlt38BDmhGVbRftoJ7697FvlbIzlpRZTn7Uv5CJ2AOD0hRx6bZfxDPVpdaspHYusJX9PU2bIfZYAoMKoqaJ96pgO1Ce4Cs/yynRGzvywHc8lhGZL5SwJry5c+rvxghd9u3ZaloE2dplNfQb4y1kXGW9yechxES9aFpVgKdqnHuYF6bzO82KI2Z0Kifbo0vyWY2EqF5ELKcvll7L2N+nY8bPFRHtMKirekB7ydTamGC8+aXWPb8/9hGyfPLUu9bnTw4OOOayRv8NdywpQn3PL5OKK+RIvU5+K57mkunFzNdEe50pd4FxU3u8oA782zaO4+Dflyveifc8b+TuPjojDD3JdyjQnAaZI+Ih4wMf4/hsw6kmLoiiKonxKqDyUvnzwlO7HH39Ew4YNkTVrVpiYmGDHjh3Jxg0GA0aPHg13d3fY2NjA19cXN28mfxp69eoV2rVrBwcHBzg5OaFbt26IiOCLBBVFURRFUT440hIZGYlixYqha9euaNo0Zeh/6tSpmDNnDlavXg1PT098/fXXqF27Nq5evQpr63eZPu3atcPTp09x6NAhxMXFoUuXLujRowc2bOBZIxKxuV2RKGQPLX9dVnx9Azcezl5Qhhd2W+N+QLR3DJAzegCg775Vor3P3i7cZ+UWOjZ8ZSd5e23lfQOAFb/XEe134nhRqYdNnOjY7+VkeW1LdZ7dYR3MC2+5fiYX7DIEczmgR1k5tl9mt1x8DwBuNebSTLUDcmZFavywWJ5gR291oj5ZM/JLzSRRlslKdOQ+sULPrXd2/pRWIQPve7XxgnzNFJzCCwcm7nakY+aT5dD+/uGytAAA3Wd8J9rdF1ygPueq8aKQw5puE+1b21SnPiuuNhbtU2bLshEAfPWEy5kZ+9wX7U8yydItAOSezyWvb3+W+3I9L8ILB57qK2dNzhvZkvp8dy+Ujrmdld/LPIr3iDKf8Vq0T/v+M+oT68Cfqbv+LvctizifSbQnREcDOEi3l5YkwhSJHyHxfIzvv4EPnrTUrVsXdevKeqzBYEBgYCBGjRqFRo3erbVYs2YNXF1dsWPHDrRu3RrXrl3DgQMHcP78eZQu/a6649y5c1GvXj1Mnz4dWbPytSWKoiiK8imTYDBBwkdIPB/j+28gTad0d+/eRXBwMHx9fZNsjo6O8PHxwenT72pbnD59Gk5OTkkTFgDw9fWFqakpzp6Va3rExMQgPDw82Z+iKIqiKP8u0nQhbnDwu1bnrq7Jl5G7uromjQUHByNLluTyhLm5OZydnZNe898EBARg3LhxKd+vnDXMrFLKQ6e7yO3OPRfx7I64rDy8ejvOSbSH5uHSR99tXUW7TR4+4cphztvV21WQV9/XzHCV+jxsIfcKWtelPvUJbsmlmel+cq+ggcu6U59cW3gWzowvZDmwXhO5EBUAFPGX7Qfv8eyJmIkpM8ySqC1n20R784ifVbQsKd3oyWWodtV54cCWTudFe6MbPPMq1kF+GovIwbOHfn7Ns908tsvbiyngRn1y2HAZ466FvL0+M7kEOnmmLLOUP8WlP/OIUDq2aEoT0X5m7wLqU3pSH9E+Zh2XgFCQ970KCpalWNcQnjXzZBkvZPdbrPycaWHCCzyOPCUfB/jy7Jwcy3jPqbuN5H3wniBLYQDwrFF+0R77msuPzz+Lo2ON3OQCd7vzZhDtiVF/X3E5XYibvhiFeDZixAiEhYUl/T18yE90RVEURfmnMPxfl+e/+mfQiripkqaRFje3d09lISEhcHd3T7KHhISgePHiSa959uxZMr/4+Hi8evUqyf+/sbKygpVVyqflHMuDYG6asr7E3X5yCf3EsqksVnvAa2JUOCI/+U/ruY76jNrQXrTn8udZUl3myIttAaBiVrnU+/VY/iR8ta/c8fRxFR5NicrPj9E3fp1Fu61bKh2Mn/HFn4MqthDtZ07z7+JJgnzKNr84gPpkuUyHMPWUvPiz+fke1Mfzghxh29N0BvWpv4OEiACssakg2lPr8lzgpFxHwySWL4a8GyV3KweAlt/IZeDPducdwYM/40+vm27PEu0Vt/HF64uGyJG8QQt5JC8iD49YWHnIT6z1g3jtmcyX5KiJ9eQQ6rM0t3wOAcD9eDnK1+qFHNEBgNkFd9Oxjhflhfy2R+RaLABg7iFfn+U/41Ha+KL8hzNTghzV+WVwXurToMY50X6jnhwNBoACWXm7kRsv5fve9h8XivaIN4moRLeWtiTABAkf0fTwY3z/DaTplM7T0xNubm44cuRIki08PBxnz55F+fLlAQDly5dHaGgoLl78I+R79OhRJCYmwseHZ6EoiqIoivLv5oMjLREREbh164+1IXfv3sXly5fh7OyMnDlzYsCAAZg4cSLy5cuXlPKcNWtWNG7cGADg7e2NOnXqoHv37li0aBHi4uLg5+eH1q1ba+aQoiiKYtQkGj5uXUoiD1wrAEwMBsMHHaJjx46hWrWUtRY6deqEVatWwWAwYMyYMViyZAlCQ0NRqVIlLFiwAPnz/7EQ69WrV/Dz88Pu3bthamqKZs2aYc6cObCzS6XT8n8QHh4OR0dHePX9RlyI699dDtdubusr2gEgqJ8NHSswVw6Dm6bSYTl6obyIbH2BjdSnzz2yYA7A8xlyXQf7s3zxGzaSQNqXXB66PYGPJSbKF2K+UXKdEQB4VpXLVyBnXnv//dRlwzS59oz9Qy5rTV/OF15+VV5ug3DDn9fRSHCRv1v7X+RS+AAwug+XEhvYyguwq5NS/QDwylv+bt1P8eNQYvLPdOwtCfnfDOeLi8PX8oW9xXr/ItqvzOetNMr0vSTa73Th38XdMXwBau7e8sL+5w24jPEml3yOu17gstuq+bxTca0NQ0V7ni28TH6cY8p72nse+spyU4eGP1Cf3TOrivbnpbn+6D35ER3Lu0NOCjixvLRoBwCHe/I187Qi//586/AF2JPdZDmz/Gy5M3RCTDSCZo9EWFgYHBz4IuOP4f3vUqcfWsPSjt8L/n/ERsRidbVN6bqvxswHR1qqVq2K1OY5JiYmGD9+PMaPH09f4+zs/MGF5BRFURRF+Xejy5QVRVEUJY1IhMlH//0V5s+fDw8PD1hbW8PHxwfnzsmLn9+zdetWeHl5wdraGkWKFMG+ffuSjW/btg21atWCi4sLTExMcPny5RTbiI6ORp8+feDi4gI7Ozs0a9YMISF80XpaYNQNE91qP4R5hpTh0tnzmomvz2TPsx28PeSS8gDQc/Nx0X7yTT7qc3xGedHeoUtr6mM6iq+kt/tV7jSdmE8u0Q0Aliay7LDqyFrq064ubzMQ6SmHKotsvUJ9rExv0LHDAfJ6/jcJPDy+epycoVP3UH/qk9ucRwZf1Jalh9IV+H7fWyjXnLC/z+XCFZ/JGUIAMLme3OU5QySXJKxfys8b1hduU59jS/hC99dF5CycO02WUJ/qT7rRsccd5fVpDbccoz4rfpJLujvU4PWQlpWcT8c6jegt2jN4cmnGc5R8HIK6Z6Q+dVfKEhAAlPKVa/q82smltZCyvK5Q6WrXRPvWVbw9wuIxc0V7233y8QGAIT9yiTagvVxCP4Mrz+R6VF3+qcl0hV+bdyZz6ai51xei3S2DfI+Pj4/Ghzfs+Gv8ExVxN2/eDH9/fyxatAg+Pj4IDAxE7dq1ERQUlKIuGgCcOnUKbdq0QUBAABo0aIANGzagcePGuHTpEgoXfpd1GhkZiUqVKqFly5bo3l3O4Bs4cCD27t2LrVu3wtHREX5+fmjatClOnjz5wZ/hz6KRFkVRFEUxYmbOnInu3bujS5cuKFiwIBYtWgRbW1usWLFCfP3s2bNRp04dDBkyBN7e3pgwYQJKliyJefPmJb2mQ4cOGD16dLIK9/9JWFgYli9fjpkzZ6J69eooVaoUVq5ciVOnTuHMmTPp8jkBnbQoiqIoSprxMYXl3v8BSNG6JiYmRny/2NhYXLx4MdnkwtTUFL6+vkntc/6b06dPp5iM1K5dm75e4uLFi4iLi0u2HS8vL+TMmfODtvOhGLU8ZN7HDOamKUPHO3+cKr4+KpVKg72789LxFVbIq+WnDZYLyAHAW5KFsK8AL2NeaxQvLhd5Ts66mNJhNfVh1PmKFzprsfEQHXsYLctX4fFczrnd34uO2U2UMxQ2r+Oh7p1Vioj23B5cR21dWM44AoDnk+WQdi8X3hF8Vma5ZUDGX7j86Llb7nILAPFl5KeSJ0PKUZ+cO5+J9ran5awdAAicKhddBIAFdVaJ9q+fyQUKAeBlQZ4hkWmofINN7bv1Xi4H8K9N5Nk+I/x70jH77PI1aHmFd6c2iZOvda+Zj6lP64P8qfJVvJwRucuOZ0RlucgzwIIvyl2t37TnPh2+k7PQzLJxOXPAHH5cWy0+ItpvRfFMs3Xucjf6hk+5tBYyh9873L+Xf7qCiQqb+DYROEE3l6Yk4iPL+P/fmpYcOXIks48ZMwZjx45N8foXL14gISFBbJ9z/fp18T2Cg4NTbbfzZwgODoalpSWcnJw+ajsfilFPWhRFURTlf5GHDx8mS3mWqsL/G9FJi6IoiqKkEYaPyAB67w8ADg4Of6pOS6ZMmWBmZpYiayckJIS2xnFzc/ug17NtxMbGIjQ0NFm05UO386EY9aRl6fffwd4+peRT6vAA8fWXfeeJdgB4UpmHuscEyyHtMTOWU5/u++XMivY+cmYTABT+jofUnh6QJZjfmvMshD4Z5ayeRXt4Zkz/b/gaezMTWV77rF8v6hNdhEtyh/JvFe21NvD+NJmHy9v7audO6nPlFM+wej6zoGg/V4qH701JksTtr/g5dOtwKTpmOUy2Z58ud38GgPiyhUT7uiKyfAAApU5cpmP+a+Tz1XPZPeqz4iTvETXaR+4kPvYEL7K3YnkZ0d65Iu+QfbEg/25jl8nfocs+fv7fWiBfT4a7crdmAFhXgDdwHXdXLpBWerHcpRgAJuTjRdpMzOWMmvw/8I7IZu7yD0iQPz92rmd55+o2/vJnGvia39ta/95ZtG8bMI36jH3Mu9GfeSVLnVeby5lS4W8S4Uaus7Tm7+7ybGlpiVKlSuHIkSNJlecTExNx5MgR+PnJ0mD58uVx5MgRDBgwIMl26NChpHY7f4ZSpUrBwsICR44cQbNm7777oKAgPHjw4IO286EY9aRFURRFUT4l/nMx7V/1/1D8/f3RqVMnlC5dGmXLlkVgYCAiIyPRpcu7EhYdO3ZEtmzZEBAQAADo378/qlSpghkzZqB+/frYtGkTLly4gCVL/ihx8OrVKzx48ABPnrwrBxIU9O6B1s3NDW5ubnB0dES3bt3g7+8PZ2dnODg4oG/fvihfvjzKlePr8T4WnbQoiqIoihHTqlUrPH/+HKNHj0ZwcDCKFy+OAwcOJC22ffDgAUxN/5gMVahQARs2bMCoUaMwcuRI5MuXDzt27Eiq0QIAu3btSpr0AEDr1u9qjP3nguBZs2YlteKJiYlB7dq1sWABb5uSFnxw76FPgfc9HtoebSv2eGjofFn0W9qwLt1mrCtv7W5586loj8vtKtoBoNNyub38htq8QfqTObz/0dvLcuZOzkM8A+BlYXl7VmH8K3f6lWe5lForF7j7bltl6hPnzdvL256V+xx5NOGh87pZ5KyewN+qU5/Ylzy7KfMZuXBZWB4eoi3je1W0z88hZ0gAQMU5PGMr2/EI0X6jNy+u5dVfLiJ3Yx6XtRLDuHxl6y7vQyl33oPmp1/kLCoAmFJNzpIbdrgV9WlS7oJoP/yAv4/tVp4J5HRVLiLXaIPctwYAejrKWUJ18/Jwd8ETcqYUAGy7WFK0513LCwdGZeULLm2fyO9l+UAuJAkA5qtln2dL+blybIosswBA4Y19Rfug+vI9DwBWfdNQtLcbsU+0A8D2gbXoWGS/UNEe9rOcwZQQHY07E/6e3kONDnaFRYa/3nsoLjIWO2ut0N5DBI20KIqiKEoa8TGl+N/7KxwtLqcoiqIoilFg1JGWMz8Uhpl1ytD/o1FyqDuyuQvdVpwdn91uWPutaO9Xrjn1mbxMDoPbVuXSTNahL+jY+ANypkapL3gYstxwuUBU86++pz7zjtekY73sZNnm6I2K1Ofol8voWPscslw3NBvvezKmUQd5oIVcxAsA8lTg2R2x+9xFe5X+slQBAD8PLC7aS33JC3LN/ZJnms3Z11i059jG5cKYb+WwcZtMfL/3PpQzjgCgrOsD0f6wiRP1MZ3KM1aczeRr8E5j3suoyCw5C83Jl2fVOZx4Q8cQJUunNTPwDLnf48hzXEIi9blakV+DLh1lia/MHN7M7n4U70F2/oGc8dO+4E3qs2FXVdHu/pJ/f8VOdaVjOYvLEtruOiWoz6nT8joHv8dcdovLwJ+pY7+XZaBc5+Wsp/j4aHDROW35u7OH/m0Y9aRFURRFUT4ldNKSvqg8pCiKoiiKUWDUkRbLMMBMaPfytrGP+HrHk/fotp7X5Svpa383WLQXsJf7lACAOUnqicvAZ9GJNjxbxAxyeHpuKC8QdfCbWaK9UiDPZDHNxuWrhSXkTAhHTzlLAwCalqxHx0Kr5hbtI559SX0yzJVD006RPBvD2oyPRfaSsy5+fMqLtIX2lrfn7sSliqDorHTsbS45A2bg9PXUZ+poue/V60G8B5OZKZc47pWXM0xuzeDnV5Y9dAiDT/cQ7euGzKA+cWVkSamkC89gctjJs+fW/yTLll924n3G4uzlbDLDbn6tl3Lh8mN+gyzX9XE5SX1aT5DvNwBgWlx+ztx+sir1Mckk2w8sW0h9mpaRs30AILiRfK+MaUNdEGOQpai8tnIPLQC4bM2fqWNI0licvXwPjY8nFSHTAY20pC9GPWlRFEVRlE8JnbSkLyoPKYqiKIpiFBh1pCXboZcwN0tZiOnZFHmmemwBz0rJu5NnfnjPliWEyHlcdmjpJrdvH+wsFyYDgBJnO9Kx5tsHiPYMD/isfG2oLM3EcuUD2Y/wMGqDs/dE+55KqZxGzhnp0BxSwKrn7+2oz/3zcmg61/5Y6vMWvEBTvom3RHvLzDy7Y1b3tqI9bDCX9/Z35QX4Qn3k4/c8nu93vRHHRXtWS14c8MeNvP9RtSs/i3bXN9eoT69GR+nY7Vi5V0+7yzwrxeFABtF+42Je6pNnuVxkDwCs3eVMkkLTePbQ7l+KivYmmeTsKgD4YZksRwOA68lQ0V6nNu8vZJaDDsGxpCxTvf1BzqYBgMI15MyiJrX5dfakJc+0jCwrS3LnPuOVUMtfkL/3CYV2UR/H7vyYx2zOJdptrsuZZvGJvABgWmPAx9VaMbpqr38zRj1pURRFUZRPCZWH0hejLuN/6aor7IQuz/535W6jQSG8U6vnZB5hMJjLKprp1bvUZ2eQ/CTcMGdZ6lPgrLwIEADiSBOtH7fLi2MBIJZ0JtjYhnfnvR7DW4rPH9tCtPsM5rVBjq7nn9fttPwk3GU1Lwee2SxctE/oz5/gh89eTccC28r1dG70TKUMd6z8Xdje488AOb7ni5WDesgRhgL+cssCADAxk8+V69Pl7rcA4JaTl3oPfiavbGxeVI7AAMCOgzzCkPln+bYS4vPhN+QCi3n9olelyCpTAM9JMONSC3mBOgDU79dftBtM+X5HuXKVnbXMcLoqn8cAEG/Py/gXmCG30qjiwKNHK4rJ58S9YbyuiusFHkX+fMph0b5odx3qk3ubvEi95ZpD1GfOoqZ0LKKMHO0xvyvXNvo7y/hX3dML5hn4d/j/Iz4yBscaLNQy/gRd06IoiqIoilGg8pCiKIqipBEqD6UvRj1pabm6P8ysUpbxj3aVpR7nK1x+ud2Sv4/bWXl7dlHZqM+WCFmKujeOh9SbZdhBx3Y0kWtO5Hz8K/VZdVXuOtzpFv+wt8/IC9wAIANZm/f9Di4BlWkhh7MB4MUOeZHu2vI8bD3+ovyZojPy77aODV+k26+JXP7fcz33CSkjXza2IVxpNX0WSsemVN8r2sf1kxf8AkDrtj+I9ugQXqfl3kO+WNPSXv68T6N5eDrvmpd0LLSYfLIUmMol1ZsD5EXWCY68nYHzsft0LCyPh2jf8IYv7DWPkb/DFwX5+RWZl0spjAQLflxdNl2mY+1dTon2oQN7Ux/7bPLiXbsyXHZ7+ZbLbn2d5IW987NWpT4Ph8nHtbPDU+qz/nd+Db7JLcsvv3aRF/eHv0lElgl0c2mKTlrSF5WHFEVRFEUxCow60qIoiqIonxIGgwkMHxEt+RjffwNGPWlxOx8LcyGzp8NcOftkvFljui3v0bzew+s1TqI9cQwPW3tZyfUCJrVaR32mTuR1EwwVZPu3Y1dSnyorhor20rV4rZi7qUS6M/0q9EwAkGDFA3ZnrHlnYfdC8putX8CPUaOJ8meKaxZKfWo34/VvsjnK5cVHLl5FfSbdqS/a71+VO0YDwKuivPjGisey9JexGu9uvGNeNdE+cRjvJp0hDw+39/xZPvcuHCxIfWJ68rYAnt5yu4VaX/EsF0MbWS40ieHdiEPqe9Cx7D/IGSa715ehPmGBclbPuZJrqE+zup3o2O3W8meKt6UuwD7e5XmMp1xrJ8epG9SnaeaLon3RgyrUZ5XfVDq2KUKW8eoW5FLwLR/5Ws+zWG73AAA2X8r3GwBIDJV/2Jks/zYyHgCXEtOSRJh8VJ2Wj/H9N6DykKIoiqIoRoFRR1oURVEU5VNCF+KmL0Y9aXnbJwzmGVKGEMvZyBkKW+vOo9sq/Dk/Ubz29RLtEZ/xsu29x8qdZC0ieYaJS1AoHev2nZxh8tNbnu3jOVsuwf7Lax7yB49Mw+wtC9Pz41C8Cg9bh5SVM3eajhpCfV5VkyWObcW5TGa2kR/zplsHivaZ9ZtQn+bbzoj2PS14f4RwXy86dtMgd1K2yCF3PQaA3Mfl7rhzd8uyEQAggRdQ/PXyWtFeYxkP3z+uym8fT3/KLtqztvuR+kS7yUX2zKL5fts+52MmP8mF8Ybc+YX69J8jt/M4WyhlluJ7npXjrSric8gSh+t3XKp7Hc47a3/3cLNoz2TK92/mK1mitRgoX38A8O3GInQsl6WcjXT4bgHqM+GaXK5/vj9vLRFrL58PAGDRSpbxXMzlaybK7O/r8qxrWtIXlYcURVEURTEKjDrSoiiKoiifEioPpS9GPWmpm+13WNullCbaTBssvn5Mf54B0OJoazrm1U/uARO0kGfGxN+We9fk2if34ACAlyWc6FhNG1kOaFONZxz1OPu9aB92iYefPQLpECotk3sM7ZpVlfqY9+H9nh4MlLOvOg+S+zYBwE99y4n2kTM7Ux+LubzzseMN+QbxxJcXYnsUK2toj7px2c2MqwEoMFvOtIn14J12K30rd6G+EMrlwqcRcn8hACgzoY9oD6vJpbVR9bbRsUm75L4xFWweUZ83c/aI9hm/+1IfexsuoT1qLEsPRSzlAm0AkH2H/F10K9WZ+hQ4w8+vLJufiPZbiz2oj2eWh3Rs2xv5njPrx9rUx9JFlqiO7OVdmRv8/AUdG+klF3jMOZsH7p8vkRuh9Zm5hfoMOyL3BQOAjN87ifbJy+VMrvi4aACj6fbSEpWH0hejnrQoiqIoyqeE4SMjLTppSR1d06IoiqIoilFg1JGWU71Kwtws5ar5BJJA4f9jG7qtInl5SPbxVllO8f5SDv0CQHBDD9HuteQ69RnlyjMriu8dINrXfr+Y+iwKkQ9E7BtZugKA+wNj6FgPGzl0nnXYduozfzZvL+94SbYf2ygXWwOAJ37y/plf5BkcOfrxJxfHGbJcYe3HW8sfjpQr/e0Zxwty9azXjY7F5pJloFVr51CfHqRZ1pCccugeAM5G8eymH/fJ2U0uOXkPmsk5uCSRb4IsqVYFzwzzKCV/F+tL8YJ5LbYOoGPesx+I9oUleMbKzZ5yP7HvKs+iPkVr8Oupfn1Zvs3bkxc6uzuAy4z7v5MzfkyG8KqQTfNdEe09KnJJ/O0M/pkaZ5B7Tq26xu+hs3+tLtotL/EMoSL17tCxLr4nRPvIK3LWX0JUNLCfbi5NMQAwcFX1T/krHKOetCiKoijKp0QiTGCiFXHTDZWHFEVRFEUxCow60vLWzRbmFinloTrt5OJf++56/6X3yTxaPkwh9TyoT0JdOaPg+1T24aofz0YqMfWeaG9/+Evqk3ur3Bsm/6Hz1GdEKoW3pjSX5bXVO5dQn3NdLtOxk98VF+2jF3I5YMCvckZBhCsPqpZe/SsdO/hYlkUsbXjBPNu2T0X7gpeVqE++VXLBQwA4tKu0aJ/94jPqMzKnXGxw+M1m1Mehvxkdi/J2Eu3B5flxiE2lsFtcyXyiPf9i3k/Ja6sstxay4Lep+IxcFnm5RG7wk8mCZ/Cx7fnflOU4AJiW71s65rdVlk7nteDFC80j6RBMgl+I9saFeQbT6a98RHv8UnlbABBznxera9i0i7xvHrwX1S+V5Gu6rBXvC9YgC78XjV4s+8Vmle8DidF/30+dZg+lL0Y9aVEURVGUT4lEgwlMtE5LuqHykKIoiqIoRoFRR1piHM0Qb5ky5O1mGSq+PsdEvq1w1xx07ElzOUTu+fVZ6hPbUu698nKfnJ0AAC+/klflAwCGZRXN2zfMpS4jFnUV7QYzLhOM/Ir3mnndSJ7jHn/LP9PDhry/iUNVOZx8IKwo9XG2jRLtJ1qsoj61f2tLx6Z7y6H9LxvI/aYAIPNc+TOFjHxFfa4uSqUQIWlL9HttXlzO/6J8HExMuEwWPY9nhkWvkm8FPZvzlIvslvx8nXi9vWgftewI9Zk8RfaZOUDuMwMABZbyz1Rgvpyh42KWSk+nTbLkdbexO/Vpfq83HbMPku8ddt78e4r34fJVkJssu137hfUFAzIUlr/bys48+zGLLT9GT/LKWWjhnjxCcPitXFwu9ooT9Zn+e2M6Zh8m26MzkX2I/fuiFwbDR2YPafpQqhj1pEVRFEVRPiV0TUv6ovKQoiiKoihGgVFHWgp9+Rss7VIWQWrlIK86Xzi4Ct1WjtX8fbwqykWOHn8hr8oHgLDnb0V7hlRCf5lb8uJM8WVlDeFeHJcQgvrI2RM5SLYKACydzItoNfpJDoNveVaG+ljzxAqEPJBD+weXysXbACDzz3JqxcQF/Lt4cdGVjg3e1FO07xvPC8U1uCBnbL3eWpj6xDfgIf98Q+WxsM94MbjAF3IBvjF5dlOfgQu49OfYQc7q2TaiJvWxHSgXGwQAM/n0x9SJvFfWG/JxDwypyvfhFZfkjnwnn+c3vpclFgB4VU4uKph/KKmECGDd7aN0bEwJucDjmaW8wF30a56543RPfgqPD+bF4HKuuiHa7+3iPcgMtnx7MT7yPsTxOnFY8FlV0e7hzqW/8HxcWn7lJT9vZ7koS87xcYng+Xtpi0Za0pc0j7QkJCTg66+/hqenJ2xsbJAnTx5MmDABhv8Q6gwGA0aPHg13d3fY2NjA19cXN2/eTOtdURRFUZS/lfddnj/m768wf/58eHh4wNraGj4+Pjh3Tm6q+p6tW7fCy8sL1tbWKFKkCPbt25ds/M/8Tnt4eMDExCTZ3+TJk//S/v9Z0jzSMmXKFCxcuBCrV69GoUKFcOHCBXTp0gWOjo7o168fAGDq1KmYM2cOVq9eDU9PT3z99deoXbs2rl69Cmtr/pTx32S0iIKVRcoFaJUODBRfb/mc15ywPMJrl7wZLC+CjXLj+2ZuKdd7KNBcfuoBgPBGvBT9g9PycRmyvQP18V4k1xOJKMw7Lzf8oS8d8ysjP1FWyRBEfVp914+O5Z8ktzTY/ush6tM4b2XR/v0KHp2JK8UXa2ZaInfPbjJ9KPWp3VlegH3oJI/2mFyWFyICwPVx8nnpNZHX0dhytqxoP5PHg/o43eF1VUq4yCX0D5biJ7lHHb4Q166WvDj7TfZUaq6QMKTzSF7yfkA2fq5M9qkhD5jwH4Usi+Vz8v5mXlrf95IHHSuaWb4GQ715TZPiBeT2AwBwJYa8ly3/bm8Oyi/aXc9xn9cF+GL9o72nifYOLfiC5NfL5TCM40h+HEz47tFzpdbXciuUmIg4nOfdRtKUf2Ih7ubNm+Hv749FixbBx8cHgYGBqF27NoKCgpAlS8r7/alTp9CmTRsEBASgQYMG2LBhAxo3boxLly6hcOF3EeM/+zs9fvx4dO/ePenf9vb8XpcWpHmk5dSpU2jUqBHq168PDw8PNG/eHLVq1Uqa9RkMBgQGBmLUqFFo1KgRihYtijVr1uDJkyfYsWNHWu+OoiiKovxPM3PmTHTv3h1dunRBwYIFsWjRItja2mLFihXi62fPno06depgyJAh8Pb2xoQJE1CyZEnMmzcPwIf9Ttvb28PNzS3pL0OGVHTCNCDNJy0VKlTAkSNHcOPGu4jClStXcOLECdStWxcAcPfuXQQHB8PX1zfJx9HRET4+Pjh9+rS4zZiYGISHhyf7UxRFUZRPjXeRFpOP+Hu3nf/+zYuJkSPGsbGxuHjxYrLfVFNTU/j6+tLf1NOnTyd7PQDUrl076fUf8js9efJkuLi4oESJEpg2bRri43mV6rQgzeWh4cOHIzw8HF5eXjAzM0NCQgImTZqEdu3eLcALDn634M/VNfniSFdX16Sx/yYgIADjxo1LYT8enBdmtikXzrmcl8PtRbrKnWcB4FwUX0yao64sHeWyfE597qyUF/uF1+D1D1CILxiN7SXXYcj2PQ/jOq2TixmUt+NyzqkKfGHvkWwlRXuvo7xzdf5lXEJYdWWPaPc+xCWlikdvi/Zl2fnC2WZf8c7CLxfKslvsKeqCy8NKiPa3XcjqUwDWNrF0LF+A/OwQ68rDrG655AWoY/Psoj79csuLjgHg6mB5EXH/hXx7hTrwhbiDx8vHyO1bLo+a15OvmagRodTn5e/8qc5tT7RoP/orb6VhZi3XV8rbipeUr/Az/95XnZJbO7jLvyUAgF9MPemYh7csN+V3TOVeNKiAaDeM5fJjjsH83BvyeT3RHjWOLzZP2Cjf256X5VLdzlH8mq5DFsOfaVtEtMcnxODvavOcVgtxc+RIXjtszJgxGDt2bIrXv3jxAgkJCeJv6vXr8r05ODg41d/gP/s73a9fP5QsWRLOzs44deoURowYgadPn2LmzJl/4pP+NdJ80rJlyxasX78eGzZsQKFChXD58mUMGDAAWbNmRadOnf7SNkeMGAF/f/+kf4eHh6f4QhVFURTlf4WHDx/CwcEh6d9WVnJm2z/Jf/4uFy1aFJaWlvjyyy8REBCQbvub5pOWIUOGYPjw4WjdujUAoEiRIrh//z4CAgLQqVMnuLm9W9gXEhICd/c/qkyGhISgePHi4jatrKw+yS9MURRFUf4Tw//9fYw/ADg4OCSbtDAyZcoEMzMzhISEJLOHhIQk/d7+N25ubqm+/q/8TgOAj48P4uPjce/ePRQoIEf4PpY0n7RERUXB1DR5uNvMzAyJie9WiXt6esLNzQ1HjhxJ+vDh4eE4e/YsevXipdMlIt5awswk5WTGKUo+ZWzMeIj+x57T6djDL2QJxtuCSzNTXoaK9iO1eSfgBEu+xKi0tyyLRMzLTH0uPpajUU+d+IVwdxbPLPq17jzR3jSfXIsCAG6P4XLT80T583rNlEvUA8CL6/JY5bn+oh0Acj3jGuvTS/LxSyjE9yHYINe/OVaZh7Mr7+P7ZzJFllneLuDRRIeGstQ5uZRcCh8AMuTlt9LvN8hdeBsW43Vaps2oRcfcouX38jnCS8effCFLdX5f8y7dfU/wFg15l8npJ07FeRZheFnZx/E4z+wrYcvl0W715bTT76vmpT7ffSZLHADwqpbsd/87OQsOAIJ724j2AlayfAYAF3rxtgUR02V57fAc+f4AAPu/chLtM4fwuj1Vf+KZjLa28vqOkEry/SYhNhq4SjeXpvzddVosLS1RqlQpHDlyBI0bNwYAJCYm4siRI/Dz8xN9ypcvjyNHjmDAgAFJtkOHDqF8+fIA/vrv9OXLl2FqaipmLKUVaT5padiwISZNmoScOXOiUKFC+PnnnzFz5kx07fquD46JiQkGDBiAiRMnIl++fEmpVFmzZk064IqiKIqi/Dn8/f3RqVMnlC5dGmXLlkVgYCAiIyPRpUsXAEDHjh2RLVs2BAQEAAD69++PKlWqYMaMGahfvz42bdqECxcuYMmSJQD+3O/06dOncfbsWVSrVg329vY4ffo0Bg4ciPbt2yNjRj7J/1jSfNIyd+5cfP311+jduzeePXuGrFmz4ssvv8To0aOTXjN06FBERkaiR48eCA0NRaVKlXDgwIEPqtGiKIqiKJ8caaUPfQCtWrXC8+fPMXr0aAQHB6N48eI4cOBA0kLaBw8eJFNAKlSogA0bNmDUqFEYOXIk8uXLhx07diTVaAH+/7/TVlZW2LRpE8aOHYuYmBh4enpi4MCByda5pAcmBoPx9ZQMDw+Ho6Mjqpb9CubmKSc6ZqHyav4bX/FMg3zZeHj19plcot3pBj90MY5yiC9LQ16q39qMyxhR8XJI29+DF9caurKLaE9IZXmQy++82JPVF3LmgvVAPtk0ecozFPb+Khery72Dl5vPdkQ+rlsDZ1Cfdl3707GQ0nK58hz7QqnPcx8n0Z551QXqY5pdLlAIAHc6yWOmvHEvcs74WbQ/2cgzT7IPkFsgAMC9dnIxuCyX+E486sjHehWVi3xt/5rLTSFlZbl1YYsl1GfQHH6uuDaSi7TVzMLlnKOt5Ay5+40zUR+LVBICWaS/egderfRGPWc6VuSAfJ+6Eso7rQc9kNc1OGbk50Pk73wfEq3k+16iYyqprmayz9rPllKXb2o3p2P3p8j3nFnFtoj2yDcJaFbsBsLCwv7UOpG/wvvfpdyrvoKp7V9/AE+MisadzpPSdV+NGaPuPaQoiqIonxL/REXcfxPa5VlRFEVRFKPAqCMtnlNvil2ejz+QV9hvLsXDzKOrNKVjS35YJNp7bObFupyvffh0OW4oD0G/zSt3PO1bg2eLZHlIerlc4p1x7zbn2T5zcu8T7QX3v6Y+G8OK07ESAfIq9Mzh/Ng9riqPdWrVh/q0Xi7vNwDM/F3uTxOUnRfXMnGQsy4cWvCMi13em+nY0wQ5rB5u4J12i/aSnzeq9S9GfVb+xEPxrXoMEO0dZvGu0Zu9eF+iecvl4+rdj8ujb9d7iPaZ9RpTH5PadAjz8sjHvN/n3UU7AATXcBLtVuX4NdMrryyFAUD1DHIj2HprecHDvGa8H/F314uL9iMVeebOooxyR/CRmbhEtbMAlzM3NKou2tccXk19alzsJtrbH+XyXgFn3jOsTNZ7on16BzkbKT4+GsBEur20RLs8py9GPWlRFEVRlE8KgwlfzPRn/RWKykOKoiiKohgFRh1pOX64OMyENOkjneUiX5UPDaDbypeVZ0IsfioXT9vYZjb1cTCRC9kNKM9XxIeXk4uWAaCrs7zz8P4vK2ttFe2BLytQn2ePvOjYzCJyf6ab3xSlPpku8qeGqWNluSKwVgPq4xQkr6Y3/UUOwwPAtlIedMxsgCwDee3iPZMKrJYL/V0eJffbAYAiTXihrBwect+Yl294ttvwwt+L9uDGPKTeuRg/rrYOclZKZnPeT+bm8oZ0LIt7qGiPHcMlJUdL+Zp5VpkXqrJMRUpsclGWHkzqOFKfis0ui/bfpvFzfEqFRnRsUxH5+rQpzCXVh215Bli29bKU2HbbYOrj2u+OaK85fQD1CanAswjNO8lZXqbg13q2QfJ5OenADuozfzY/rl9kOS7ae5eTe2glxJgCZ+nm0hRdiJu+GPWkRVEURVE+Kf6BOi3/JlQeUhRFURTFKDDqSItzyWcwz5CyUlq1DfLKfO8lwaIdAAyWqfQjaSlXY+s6n3etjr/gJNrjuEoA1/Ny3xMA6DJ6l2jf3pT3MqpTTT4OedpyKSXyIs8ecvKRM5iKlZLDzwBw/TnvsdJ7+xei3Zl/JLz2lkPQU9f+Qn0WF5ZDxgDg33GbaP++HvcJqiEfhzonjlGfUy/z0LFM1nJ1siUF1lOfxufkzLW8neWeRABg4uxExwyvQ0X73M4tqE/Luefp2JazZUX7s678HMdb+Rkq+/fcx/6sXEAOAH6cJGc+Ff+1H/V52FaWr6xzcfk4kddhg7O1XOhyat7vqE//tfwm8bKgfMt+W0x+HwAYk/UH+X0au1IfiyCePTexxQbR7mjKC6oZXsjZVwO2d6Y+eYMu0rFOO3uL9jwzT4n2eEMcrtGtpS2aPZS+GPWkRVEURVE+OVTiSTdUHlIURVEUxSgw6khL4pbMSLBMGZLMkFEOrz2vwjMXho3gofilbeRV7DtLLqQ+zfcNFe0jB/EiY+tTyVCYukfeB/fZXPLKYJDHzE14ZsCWTjPp2OCxctZR2FieNZMzNJyOrdyxWLR3W8gL5pnHyCHtsd48kyVqHO84uq5/EdH+rCSXC3OZBYn2o0V4SN3MgYfvv/71gGj/MpWCeWNXy9LHYt9m1Gfk/FV0rO96ueDapDbrqM+wc/y9vOaGinaT5zxrxhAlH6Obo+XvCAC+n7eTjvV/XFW0m8pJSgCA/JtlualIBll2AIAl3zShY5HTZbm1V2kuUQ35ZiMdG72xrWi3t+fn16Fw+fhZHefnq9uJUDo2LkLehxUH+bUesTlKtOc049mPzzuVpmO3Wsn33mIP5YKVCTHRQCrnSlqi8lD6YtSTFkVRFEX5pNDsoXTFqCct2bregUWGlKXOb72Sn26yOfGnvF0veLTg/nDZ3qshL0Ed2kWOZmSz4PuQGMafVPIvk2t5vC7JF9NleCo/Uhaaw5ekfTF2IB2zqS8viIzKItdtAIBM527QsW6V5Se2F6lExMzIekjH5fypMZ6vqYVFuHyMSn3O93toTzkyMrixXKocAJ585kTHXiYeFu1PK/I6LcWtHon2h7X5JT3vkVxaH+AdpSddr0d9vq/MS8fPW1NFtJ9YKC/QBYCXpeUaJJ7f8UWwZV4PoGO5Nj8R7Ta+1AVvE+TWCdN/492pTbPzJ2PXbqGiPVNPHu1sYRdGx1Zukbum92vPowhDF8jnZY5D8j0FALrv3k/Hhl+WW568uSUvUAeAp0HymGk0P3b5v+eLrP2+lM+jGLIoOkHuvJFOmPzf38f4Kwxd06IoiqIoilFg1JEWRVEURfmkUHkoXTHqScudbXlgZpVyIa5NXbkk+ZU7Oei2vKZxaSY3iS3encjrEtgfk4NY02o1pj7uJ+XQLwAMc18j2r+PKER9DnSQF842cLhMffbGVaVji+YHivbmC3kJ8dAtXL5K3JBZtL8oya/aH5tOF+11A+WFzwBgU5Ef19DHspS4P9cx6uP3WG7r8LCuE/XJtZLXsulWvaNoz7GG19MZ10ReeJxgJ0ssAOBuw8/x20SBSa2Dcf3VvFPxtDZyx99hY+Ty6wBQd4q8PatH/PszKcE7o086Ki967zO8P/WxMiUSVX/e1gHRsgwFAE06ynVzdi4uTn3Wv+GFX6wWytLRsLlcmozIK8u6Qd35sfvuBV8EO6DwUdE+PYZLaF4T5VpEJTddpz6XArPTseNbS4n23HvkcyU+IQb8CkxjdNKSrqg8pCiKoiiKUWDUkRZFURRF+aQwmLz7+xh/hWLUk5Yt/QNhb58yWNToihwq3V1tLt1W5xOD6NjSUbNEe1YzHopvP9tPtCc62FCfC0+5fNVhmSzBdPGX63UAwKOacjdb/x68/seypbxOS70f5NoSxerJXY8B4OY+Xr7eJKtsz3yBuuDz67IMtHH4DOoz+gHvFuvSR64TUSyQH6PiTa6K9px7eGaYTyqZEJs35xbt17/i3YhxW856ulFvEXXx3so/k4mLHJMOvFqd+mQ9wbN6inUKEe3lv+fZaR535esp1o1nhuX8lkszfWu0Ee0OQVwm23WpuGjP7sN/SJbOku8PANDzhpwhZ5XKvSOnhVzyHgCeLJfPlcb+XMYzI3WZTn4pd20HgCfF5G7qALCrrtyaw64zv7ctPyRnmqUW6u+YQ665AgA5v5NrUFXbIbfziI6IxxGfVN4sDdEuz+mLykOKoiiKohgFRh1pURRFUZRPCl2Im64Y9aSl65C+MLdImcETWkUOIH25moemsxznmRo9m8pl5W3mOlGf6WsXiPYFIXLmCQBEfcMzgRJ7y+HQ3k5ykTEAmOkqn/2Vp52hPl3H+NMx791ywbXfhuWnPpapnGFZj8mlvW+1lrtqA0DOArLs0O1rvt+pdC3A740iRXtsHh6+P3XOS7TnmMFbKvwwgreuzpIoyyxfBModqAHg65Ny6fhCqXQItucV0+G+5nfR7nvqIfU58jOX/ha8lD9vwemh1OdaXzlrZncDXsSuyWm52zUA2O2Ui/M9bc9/FZx/lmWgmmOPUZ+XCVwWeXAni2j32Mb34fxMTzoWbyvv37kuxahPTCZ5/8atX059Aorx8/VZG7ktwICevHP1oSgP0f48nkt/weV4sTr3xnI213cBcgZTQmw0ALmIY5qja1rSFZWHFEVRFEUxCow60qIoiqIonxImhnd/H+OvcIx60lJpxFlY2aXsxrvheEXx9VEdQ+m2nlSRV+UDgNtaFq6TizYBwMwntUT767pcq3gwnY9Zhcmh0rVveIGoIqXlckrrj1amPpm5KoKQ1fJ7JTzg+52zDJevTNfJp595RDbqY9tKLq71YAY/Dt6ePMPEz/2saJ/wS33qk2eEXCgrrDjvmZRh3zk69nCrLAuua12b+njIdflgNeI+9VmZdwsd63RRziza48+lv0Y/8HD77B/k8z+PG8848lokf7ctgnlmn2ulVLqcn5PPS7NYLklEk7pupzsUpz57i8t9lgDA3kW+d0T2431/tgbw793ti3uive/gI9Sn11G5eGFhS1meBYCQ9ryztutGOXtu63F+X7nbWpbJTIryTK6YXPzX+/HeXKL9TTX5/Ep8Gw/w0z9t0TUt6YpRT1oURVEU5ZNC17SkK7qmRVEURVEUo8CoIy0/h2aHeVzKTJMGFS+Jr79R2YxuK7Z/CTr2tLoccrRyjKE+z/d4i3bHOlxK+bXubDpWaZqc+TTn+xbUx3n5KdFuM4xnfdiGyEXLAMC8oZxhleBXjvqYjuHH6NZAOcRrKasEAIA+5+TMp/675YweAJifm8eFc5rLGSZzd8t2AHhSV5bq4rjqgKLnLOmYeQe5t5UhmEsI9/1lOdNps3xMAaBefd6fxj6TvH+5R/LeMKvn16VjWd7IMe6H1Xm/rq9ayYUS7U3fUp/IRJ5pNqtEK9HueoTLhYmPZbnpSZ+S1Cd3Y15cMfIruYJisCnR9wBkvSnLjwDwbb4dor1uT7mYJQDYdpZloPY+zahPllc/07HMR+Vz5cdfec8kF1Iw8m0CL2LnXplLfwne8vO22V5ZhkqITQAXqtMYlYfSFaOetCiKoijKJ4VOWtIVlYcURVEURTEKjDrSEhFrBXOLlOHhoHLyVDX3aT6FNa0TRMeuj84n2mMteMjflBzZDE+4XFJrSH86NmCMXLgpWyp9Sr5K/EK0Z7zBs57uNuISmvsguejV23Aezn5kwbNPEj3ksL+7q9xeHgDmFZSzGk7cnk592nUdQMdCehHpIRtfDPe2oCzn5P+SSynP63Ht6G5LWSrINYUXdnPfKZ97xYdfpD6XJ3MJ1O6i3BspINt+6tPqsSyBAkB0D/m8DPTaRX1G/C4XzEv8gcsOjnWf0jGXpbI8av2TLCEAQB47WR7d6zqf+tT7XM7OAQCLZ7LEF9mD78PnXX+gYzNeykXkLAbw43Aw/0bRXmXQEOpjyMwz4TbkkI9F+1b8HH/YIqdot3vE78kO/fm9qPtu+bycHiIXAo2PS6XCZFqjkZZ0xagnLYqiKIrySaHZQ+mKykOKoiiKohgFRh1p2VNwBxzsU867Tt5IWXAOAKYU4r3Jb43nMkZmsvI9LC+Xh8rUlXu5nHQsSH3yDuUFyMb7fi7aM16QPysA5O0m9wpqkPkK9Rm3tzkdm5xf7oUzfMSX1MfhFi8ehWNyHPTtFB4W3nX3hGg//JaH261Oc9kGpYuK5njeTgaGWHn/PI/zEPT9JvxccawqH4enW3gPmgmF1or2oes6UZ9uYw/Ssdp2v4n232MdqY/dZZ6FY9dDliADgwtTn2HX5P1rUJJLH60q8vMVeeUMq9+Pc+kjepn8xecZVYr6mLXht9FSPvK+5x5FXbB9qS8de1pR3j+LN3x7zV/LMlCBQ7eojyFzRjr2W0Vb0f6mJC8K+dZdPsfLtfqF+pxy5/2UFnSRv/fP5p0W7TERcTi/nW4uTdGKuOmLUU9aFEVRFOWTQte0pCsqDymKoiiKkTN//nx4eHjA2toaPj4+OHeOR+4BYOvWrfDy8oK1tTWKFCmCffv2JRs3GAwYPXo03N3dYWNjA19fX9y8mbxW16tXr9CuXTs4ODjAyckJ3bp1Q0QET8xIC4w60lJpyZcws0pZrMr+oTxVNa/Hp7D5Jsr9NACg4/lfRftXZxtTn+dfykWl0JXvg+GQOx0zPyvLQFla8l4zuTLIGRyre8pSEwAkduK9Yb4a1EO0W0XyhkXrdi6hYzsj5PD9+r4NqE/cSlmCGX5FzjwBgFy5ebbUvl5TRXuNzTyzokBfWfqz+okfh3udedE3a5Is9eY+l2aueMrZGLkmyL2UAODodC6LrPtC7hU0ue9y6nN3hhMdy+H8WrS3yvqY+izuLxc7G9dNztYCgMpb5f5aAHDpWXbR3ikX79NzfKxc7MzlLJc+TBP4NX3lrSw753kcQn3e5ubZUou7y5k7OcwjqU/TiUNF+63+clYkADSqJxdxBIAJnTqL9qef82dgu3vy4tKYivwnqMTn/J4cfFKWTi/2Ki7a4+OjAfDMNWNn8+bN8Pf3x6JFi+Dj44PAwEDUrl0bQUFByJIlpXR+6tQptGnTBgEBAWjQoAE2bNiAxo0b49KlSyhc+J2EO3XqVMyZMwerV6+Gp6cnvv76a9SuXRtXr16FtfW739127drh6dOnOHToEOLi4tClSxf06NEDGzZsSLfPqpEWRVEURUkjTPDHupa/9Pd/2wkPD0/2FxPDy2XMnDkT3bt3R5cuXVCwYEEsWrQItra2WLFihfj62bNno06dOhgyZAi8vb0xYcIElCxZEvPmzQPwLsoSGBiIUaNGoVGjRihatCjWrFmDJ0+eYMeOHQCAa9eu4cCBA1i2bBl8fHxQqVIlzJ07F5s2bcKTJ3y928di1JGWVV3nwk5YiNu3e1/x9dGZ+KLViOq8DHx1m32i3fIOL0ke7S4v1rR8yeeJJsP54rcBq+QS53t9+cLGbVPlhWzZR76kPs4xvCz6k8/kJ8C8G3m32HZN+SJds5dyGPHpFH5xTn4hL6a2PszLgUe78dYE1bYPFu2WnjzEGTRFXry72TWQ+uRow+vp7O9dVbS/deXn1/rt1UT7sN/lej4AsLV+BTpm91iOYA1dyEv/j+i+lY4tGiNHTX4fyhfVhvaSV5M6buXXxRlXvliTfaa+0/jizxVreop2Jx6cgct6XvLedHsO0R5kyxeO5zjCI4Ojv+wu2p9UTKVNRF25L0ZGK35dfPdTWTqWN0GOfK1tPo/6jOwpH9fn9fn98OVa3rnd5ZV8z3ldTL5HJcSaAqmrJWlHGqU858iR/NwZM2YMxo4dm+LlsbGxuHjxIkaMGJFkMzU1ha+vL06flhcmnz59Gv7+/slstWvXTpqQ3L17F8HBwfD1/WNRuKOjI3x8fHD69Gm0bt0ap0+fhpOTE0qXLp30Gl9fX5iamuLs2bNo0oRHvz8Go560KIqiKMr/Ig8fPoSDwx8PY1ZW8gPlixcvkJCQAFdX12R2V1dXXL8uZ04GBweLrw8ODk4af29L7TX/LT2Zm5vD2dk56TXpgU5aFEVRFCWtSKPsIQcHh2STFuUdRj1paX2yO0xtU4bQzarJodKD7eRFlwDwTXBtOlb1rBzadK+QyqLCzvJCpO595G7NALBl21I6VnyXXOI/bx4e4s3bSQ6DP9rKpTCzH/niT0eyHtLsMZebbgzgC1Bt88lhcIvjvBz4+Tlyt924MtQFD7vwBbLmd+RzJctauRYFAGyeN0O0V5nKF++u9J9Fx1YPlLtkJ1zl8pD9Pdk+/nBj6lPgqbygHACqfSXX7Ni5rjL1Wdm3ER1zui0vNG2RkcfoLUzk82FPdi5rsUX3AGD7TF5UviY8L/VxPC7XQcm0lhRrAhA0tzgdszov32Jd7vD9funNb8snBswU7adi+HU7tbfcZuBea16MKP86vrDXcE4+jybU4F2jTXLLn/fBMpKwAKBlDi677apQVbQ7X5Vlo3cLcf8m/uaU50yZMsHMzAwhIcmvuZCQELi5yYvv3dzcUn39+/+GhITA3d092WuKFy+e9Jpnz54l20Z8fDxevXpF3zct0IW4iqIoimKkWFpaolSpUjhy5I+FV4mJiThy5AjKly8v+pQvXz7Z6wHg0KFDSa/39PSEm5tbsteEh4fj7NmzSa8pX748QkNDcfHiH/3Ojh49isTERPj48EKuH4tRR1oURVEU5VPin6iI6+/vj06dOqF06dIoW7YsAgMDERkZiS5dugAAOnbsiGzZsiEgIAAA0L9/f1SpUgUzZsxA/fr1sWnTJly4cAFLlrwrUWFiYoIBAwZg4sSJyJcvX1LKc9asWdG4cWMAgLe3N+rUqYPu3btj0aJFiIuLg5+fH1q3bo2sWXkE7WMx6kmLwWACQ2LKVdoFyt8VX9+1O5dm7tfjpeMLLJdX399pzms39G8l1xqx8eSZNiEJPGvA+bK8f7fa84yolnPk7c115rVTZmSvyffBUg4Zn7tZWrQDgMMdvoo+0zZ532925nLO9/5yhkLFbYOoj+FtKqe5p9zlOcTAQ+eHojxE+7pBsmwEAEOrt6VjMQHy/jkFpdIBt+Mj0T7dcy/1GX6WZ3KNziwf14t7eSfn1yVd6JjXJDlLaHi/XtTHdZhcc2Vh94XUZ3I1XtMnorh847z4hkuW276SJeSQ4Vyq+ymKdyU/3ErWLbts+576/BzF988U8vU0fA7P8rLPIN8HKnvx9hY38/DvPbyGLNflOBBKfe62k+2mb3nW04HJVeiY7xC5g/eOm3JmX0JUIiAn0qQ9/0BF3FatWuH58+cYPXo0goODUbx4cRw4cCBpIe2DBw9gavqHsFKhQgVs2LABo0aNwsiRI5EvXz7s2LEjqUYLAAwdOhSRkZHo0aMHQkNDUalSJRw4cCCpRgsArF+/Hn5+fqhRowZMTU3RrFkzzJkz569/9j+BUU9aFEVRFEUB/Pz84OfnJ44dO3Ysha1FixZo0aIF3Z6JiQnGjx+P8ePH09c4OzunayE5iXRZ0/L48WO0b98eLi4usLGxQZEiRXDhwh8L2f5MeWBFURRFMToMafCnUNI80vL69WtUrFgR1apVw/79+5E5c2bcvHkTGTP+USDqz5QH/jPkXRILc/OU867EF3I+u/3Kh3Rbpmd5R12TF6Gi3f20HfXJsEs+tFGteJGx1gE8++SzL+Wsi1exGajPLzXkolzuv/Cv/UEXufQ5AJyuJRd7yv6AlyRP7M/lq5fxciEor0G8+Nehqh6iPf8q3k36RSknOlatj1yu/GCGAtRn9s3qov3Vc5711Pq783TsxlU5IyrDU95S4fYDV9E+dD2XgF4Vp0Oo3UX2eziaS3X5h/HradZUuRv33XlHqU/PG7KENmqg3D4CAB58zTtr9/A5JtqPfSkvTgSAX9dkFu0zehN9A4DVcy75vi4pZ/WsKMy7ytsd5ZlAx+2cRLv7CX7+32kmp82+fsqv9Ynj19Gx8ddlSc6hPpfJTO7KbSfsz3AZ1iSBf7cNHeXMogOnZOkqIebvExW0y3P6kubf5JQpU5AjRw6sXLkyyebp+ceE4L/LAwPAmjVr4Orqih07dqB169ZpvUuKoiiKovwPkOby0K5du1C6dGm0aNECWbJkQYkSJbB06R/1R/5/5YElYmJiUvRhUBRFUZRPjvdl/D/mT6GkeaTlzp07WLhwIfz9/TFy5EicP38e/fr1g6WlJTp16vSnygP/NwEBARg3blwKe+8V22FrnzKrZtQUeSW9awu+bsYwjA7h6WI5XOvaSu72CwDP/eXeIk/78FQw9zK8yVRkgix5tczMi3VluSj3cim6R+7NBAAFrHmo2y1QllJe7s1DfTJ/w+W+bzfJhbKKl+pHfRZ/JfdaMs/OQ8kmqXThbeEkH78z43m1Osf+D0R73FGeTfOiEJcS7U/KIfKHNfl+e26QpaO7bbiklCGjnCkFAD3m7Rfta5/Ihe8AIKoQz55r0FaWdOJGcXk0+LUsY2SP4BJVrh086695zUuifV21GtTnYGgR0f68RCq9fVLJgAnzkjN3Ypx4xl1MsHzdAsC8OFmaNA3mx7VkFTmT6+x1ucs6AIybIxekA4BYUqT11ivenbrACbJ/D25TH0Nufn4x4klNyAR+mqQ9/0D20L+JNI+0JCYmomTJkvjmm29QokQJ9OjRIymP+68yYsQIhIWFJf09fMi1dEVRFEX5p/ioDs8fuR7m30CaT1rc3d1RsGDBZDZvb288ePDu6fQ/ywP/J6mVHLayskrqw6D9GBRFURTl30may0MVK1ZEUFBQMtuNGzeQK9e7gkn/WR74fQ+D9+WBe/XihackFpYtCnOTlKHZfbemia//vHFnui3Dixg6ViSTHF4deo33q/9ysFzILu/p+9Tn/hwnOlbXXZaifovmGQDLf5NX0t/6fDH1KRTSh47F9JGzXOxjuaRUfR7vH1I1wF+05/mVyxiT18iF8YZ35lkzcd35Gqgv5spSVPaLsgQEAPH15GKDoy7zegW1bXnX09I55YJYhlSuzrf+oaI9405ZlgSAzv0O0bHx6+QF8E63+GNfxl/5MRpw/KBon3CbF4NrnE/OGvuuLs/2yV2SR117dpP7dU1etJr6jJ3RSbQncuUD7it4tpvrW/lcNsvHpZlrJOMIALaW2ybae33Le6e9ai9nEXoseibaAeDtD1zGdl0gS6ouP/GHyc6D5WyyryZ9QX3i7Pjajh8j5f5pbmfl+3h8fAxu0K2lMSoPpStpPmkZOHAgKlSogG+++QYtW7bEuXPnsGTJkg8qD6woiqIoRsnHSjw6aUmVNJ+0lClTBtu3b8eIESMwfvx4eHp6IjAwEO3a/VHn4M+UB1YURVEURflPTAwGg9HN68LDw+Ho6IhxZ31hbZdy3rVuWS3RL0+zW3SbNTNdpWO7axYT7Y+a8x4hqBoqmt2b8wymOxN4xkqJynJw08Uqgvrcby4Xyiq9S+7NBACeVs/p2ITvm4j23Ntjqc+dJjyzItFGzvjJ5cnD1j1z/Sja5w/n5ahDO/BjlGmJnG5wvxW/LBoVuSzad1+XM08AYFzpXXRs1sxWot28Ef8urBbJIf9GAYepz+EKOejYveVy8a+EBL7s7XxFLjM2viZ/Ji8nXogwl81L0X4plF9nT2byzLXqY06K9u9nVKY+LidlGS/bRn5O3phQiI49ai1nc3ms4Mf18WdypiAAxGQh/clM+fnapMxF0X5kDe/E6/5DKB0LnyJLMKZL5fsNALxuJ2dE5RjH9/tGVy432TyVj5/LVTnTLD4uGmf2jUZYWFi6rYl8/7uUe9Q3MPuIB/CE6GjcmTgyXffVmNHeQ4qiKIqSVuialnQlXXoPKYqiKIqipDVGHWlZ+Xs5mNqmDMNN67NGfP3SOjXptlZ81pCORXWQV7HnXMCLy930kXsZmXrxrIFuDXl2x7JfKon2/IPkzCYAWHJuo2ivspX3OLJ4w1fse62QMzWe+XLZocC4a3QsogrpvxLPM2CmZ5WzXGZPn099xucuQcfifeUiXyZh/NJolFEuWnZ2Dy8YNv6+LJcAAGRlBplW82J1NSceF+3r59ahPrG8hQ+ig2XZwXs6z3oavIUXaXu1Vy4MdrEmlwvvtZKP+c2lPEPOxY4/d50YJBfGe9aIP8pGZHUX7TUyXKE+OSfxwm5338rf4dMQXjgt5wFeTM/8aahojyok96ICgD0vZRlodt/l1Gfsy650zLmVLKUbYnlxzIis8jW4ePdU6lP9J14E88uacg+rOfvqifbEaDNgH91cmqK9h9IXjbQoiqIoimIU6KRFURRFURSjwKjloTz974rF5fynyS3uDSN43C1HTh4GP1xQllm61eeSUv72r0V7jb2/Up/vJshZTwCwaNIy0b5ka1Xq80V+WQ6zHMolII9ALnkZssoh6Jp95SwNANhUmUsm3pPlsHqLHXKGEABM+U0+Rt/Ua0l9YuvLmTYAkGAhHwuvBS/4PgyRP9OLNbwo3vKysmQJAH5z5KKKFlG8n5Kv/W+i/fQuD+oTuoI0ZgEw1FM+5uMy8mJwqMuzstzyyNkiVbrxQmxNfpcLEX4xSO43BQD7AmfRsVaNSOEye57ZEeUl3yNexNlTn0ul+G3U1Esu0navKZf+rLnahIic8ndYoiLPSnx0Jp9o73VELqQHAOV68lJs0d3l4/e2Gj8fXH6TM45qrh1KfRKdSaYUgDUz6ov2M+Omi/Y3bxKR5yu6ubRFF+KmK0Y9aVEURVGUTwld05K+GPWk5VXDgjCzTDnr99guL2R7WIN/3OhTct8jABjnV1G0X7rEa0QUsJMjLfN+4IuB3VM5WftslFdRHujIF7JN/0leKHnjajT1iagml8cGgAz35afnEra8NcHlKQXoWJGN8tPhliZVqE/MMHkhZ/x1HsHKuZKXRX9eU36ae7yeLy5++7scaRlSbAf1GTGMtxmYMlleEDl8rtytHABGfilvz9qFP+06tuU1UuasrSbaLa/LHagBwDqVDstRA+STef/XVanP6tLy+ZrQjLeJaPOZvDAbAHJtuiPaY77mdVWsH8ktH04FygvrAeDRNHnxLgDkKvpYtDut4Bf76gA5WgAA/bzl+0eEDf+eLHrL0USP3XzBb6G5fFHtSR8n0b79wWnq07BjcdEe58SjKRl/4efXGw/ZvvBVKdEeHREH4ADdXpqjE490Q9e0KIqiKIpiFBh1pEVRFEVRPil0TUu6YtSTFvsHMTA3Txn6jBslr2QblP0C3ZZHM14yfW5ZuUbKycszqE+3SXLJezMXHsZ9Wpd/HV1LyotdezblnbFvfCG/19F6M6lPQ3suY9h1lOu0jFslL3wGgHg+hOImQaL9+lBeutryAZGHavIFv+2z8K6+fsvlHXRfykupm5MSG2VseHuEgBp8Ua3fTrkmhl0qN683/Unnakverfztai79ZbeXpZTgu3zB6NUjeelY7qfysbAPjaQ+pvGkDLxPKPUJLcNl3cSeGUR7vTU/UJ83CR9efv3sEN5puvM1+TjMAa/bM6AWXyD7vL1cw+joaH5Nt6ovL6A3fcrveSe685YiL9rbifamufkJu/eO3PLhQgyXgDqY9qRjOfPKUufRwbKUHx8fjb9LHtI1LemLykOKoiiKohgFRh1pURRFUZRPCpWH0hWjnrTEDXkNQ4aUYfxsGcLE1087yGtOmL3lQae638uyUpVTvamPaW85NJ2vB89yiS/Gs5EarZNrWOzPyzNtvGfI4d92Hjz8HPlUDv0CwI1xcr0Mz508G+lFER5uPx5QXrRvnjyP+rTb1E+0321HXRBYiZebL7xFboPwzIq3Wzj6tRyKb5W/OvXJV5x3wl67WW5B0KVqe+pzPY8c8nfuf476VL58m44NcpHP8aqO/tSnZC3eouHOTVmKyniFFyEJzynfjo55b6I+bS5y/fHa4EyiPewbnsFnf0+utfPqK57BlMWZf6ZvFssl9A28ij8sIrkk53pQzkYqk4t/T7mvyd/t/UFcUjXhST3IsVeuYfRgI79/eR+U7x0LPltLfTzy8tpZUWvk+jdFJ8p1gGIjYnHyCN1cmqLyUPqi8pCiKIqiKEaBUUdaFEVRFOWTQuWhdMXEYDAY3SEKDw+Ho6MjahQYBHOzlPLQ9T5y2fYFdVfRbfpYhdKx3vdlWelFNC+LHrlc7kyb8eQj6oNUvoolJ+UQeY/ijfj2zMnKfCeendN33246NnyOXOysabdj1Gd0Ji4hnImRi1tdjeGxc1tTWWZZW18ujgYAQX1IVgqA/U3kDLD2v3WmPoZvZdkhPA9vj5DajSjrT/JnKvINL3l/q7lc0OxFVTlsDgB1Bv5Ex8Zllts3rH/jTH2sTePo2LJishzwZIMH9Yn5xUm0O93kB+9tZn7MTavKss2bW7ytw/EW00R7j5KNqY8hCz9GPXbIrYWLW3HpIzTRgo51Dhwo2jM85dlpGR7L8q3FNZ715LCLDuHsLQ95IIo/A1s9k+9F2X7k2W5Wv/H9e9JSzlxLIEl/CTHRuD5nJMLCwuDgwO9/H8P736X8/t/AzOrDs9DekxATjRsz03dfjRmVhxRFURRFMQpUHlIURVGUNEIX4qYvRj1peZvDAeYWKcNw2fM/E18/dpxcxAsAnlXnoW6TMPkw7WrMO8z2e95XtMd6cKmizOyLdKz58CGi3SnqMvV53LuEaM9+SO6LBABX3uakY+eHzhXtXke6U581rz6jY9kLySHyDD15yN9gLYfOr4/gYVSrBzyg2GSRfFzjufKHbO1kic95JO9xFPeNnNEGAL1bHxPtI7fw7CHXEnJ6R7gnP3ZrL8jZWgBwfpbcj+dlaS59JJrx93oRKEt/LXLxAo/7T5WTt1WK38XzFOUSgqWpfIziS8g9tACgU+f+ot0iO+/gbT37JR2rYiNn8FWex7sbp5q5s0yWDO8NKkp9It3lkzmqAe8LlnEpP+b5bsjH4mURXpAxywk54+h6Xyfq03BKKB17PVPeP9NY2R4fx+WzNEfXtKQrRj1pURRFUZRPCp20pCu6pkVRFEVRFKPAqCMtcXZmMFikXJXelvQY2vawFt1W6cK/0bERrnJVou5FeLG6V+3lHjnZm/P+NAfny30zAMAqQQ5vmtpyHSOuvBwGfxbBsycWX+DF6nYc8hXtV6YEUp/i38rhdgBY77VOtNdtzEPnI7+Us6isTXjxtgVdmtOxvZuXi/aO9/i58uKrXKLdZrpc+AsADFV4n5elZRuL9oxjuM/zOFlmzL36CfVZclw+3gBQ71f5mGddeIn63BtRko4VHCdLaN8NK0t9BnTeK9ovhcvHGwDuv+HncgM3uZDj5jF1qc+LavJzXGJeWe4CgI0599CxMt/K2T5w5Y/TlcvLmVwAcOOhnJWVSiIX3njK9458G3jBvIc1eZHJ0HzyPeeXznOoT+EfvxDtrnt576G6Na/Qsd+ey3JY53k7RfvbiHic30E3l6bompb0xagnLYqiKIrySaHyULqi8pCiKIqi/At49eoV2rVrBwcHBzg5OaFbt26IiIhI1Sc6Ohp9+vSBi4sL7Ozs0KxZM4SEJO+y/eDBA9SvXx+2trbIkiULhgwZgvj4P6KTx44dg4mJSYq/4GBer4hh1JGWrL3vwCJDShnmyEtv8fVm0TzEe24+D3W3ipCzcHb/xrOHWnSQ+3AkrONZCIY2dAixGeT5ZUxxD+qTe0SoaL/2lSxdAUD+BVxmMXspZ0nEga/Mb1n1NB1zNJEzgd5481j32upyBszK01uoz3xzPjcvtEbO8vJvzKtreSw/IdprWPNwe50aX9KxYB/yfZziIfqATmtE+6SHHanPytdl6FjhlnIRwDmDj1Kfti149smd2XL/HJd9PONo00lZtnlegn9/ma7wcy+wHunh05Cf4w4X5KJg33daQH3OxmShY/nHB8kD2eTeUQDwqiSXfFdNkYshepjzYmb12sjSjP0Mue8WAOSO5z8Nv1+TMwyLL5X7ggFAvuly1tP91R7UZ251LtHeHSbLSlN+l30SomIAnKfbS0s+ZXmoXbt2ePr0KQ4dOoS4uDh06dIFPXr0wIYNG6jPwIEDsXfvXmzduhWOjo7w8/ND06ZNcfLkSQBAQkIC6tevDzc3N5w6dQpPnz5Fx44dYWFhgW+++SbZtoKCgpIVzMuShV87DKOetCiKoijKJ8UnKg9du3YNBw4cwPnz51G69LtmmXPnzkW9evUwffp0ZM2aspp2WFgYli9fjg0bNqB69XcNYVeuXAlvb2+cOXMG5cqVw8GDB3H16lUcPnwYrq6uKF68OCZMmIBhw4Zh7NixsLT846EsS5YscHJy+qjPofKQoiiKonxihIeHJ/uLieEtD/4Mp0+fhpOTU9KEBQB8fX1hamqKs2fPij4XL15EXFwcfH3/SMLw8vJCzpw5cfr06aTtFilSBK6uf0QPa9eujfDwcPz+e/JF5cWLF4e7uztq1qyZFKn5UIw60lLZ+QZs7FJ+hJk7Pxdfn9Cah5LN5PYcAID6vnI2Uvuq7ajP65pyoaWYvryvTtRzLl9l/Fn+qj6bxeWXM23kTIPUyDybF+u68UrOWCm/YhD1sX/A32uHu5wt1aYZP5m/9ZN9OrToTX0sbvCMrbwh8mdaXrQC9emRW5aHfgSvCpbvm6t0zLqjfE5cS6Vg3ucZ5Mywialc0c9j7enY7VC5n1L7PrK0AADRObkk4dH2Z9G++BaXm3o2kIsUlh5ym/rcGM8/sNP38jU4+uJh6mPxmXyPqP9LF/4+UzLQsQkXl4n27gtlWRIAEp7z3kMzbGqK9oft5F5UABA5Rz5X9njupz6/cAUNAxb5ifbhE1dTH39bWbbMsYTf8yYfl48dALSf7S/aCxaT10jERcbiBt1aGpNGkZYcOXIkM48ZMwZjx479y5sNDg5OIceYm5vD2dmZri0JDg6GpaVliuiIq6trkk9wcHCyCcv78fdjAODu7o5FixahdOnSiImJwbJly1C1alWcPXsWJUvypRkSRj1pURRFUZRPCZP/+/sYfwB4+PBhsvUfVlbyJHz48OGYMmVKqtu8do03rv07KFCgAAoU+GMNXIUKFXD79m3MmjULa9eu/aBt6aRFURRFUT4xHBwc/lSX50GDBqFz586pviZ37txwc3PDs2fJW9zEx8fj1atXcHNzE/3c3NwQGxuL0NDQZNGWkJCQJB83NzecO3cumd/77CK2XQAoW7YsTpyQo9apYdSTFkuTeFgKU9osF+QQ787AmXRbjfvL4UYA+G2fXMjIMjpEtAOA215ZF3lkzXv75GmQSiv2THJfmyNfV6Y+Q3fKGSZ9j/OeNtUyXuf7MFpuB+8wnO+3yUGSwQHAqY2cjXR+QCnqk81aziwyvykXMwOAvAcj6ditevIl4GTNpY+fI+TvcPncRtTH8RbPGkvIJmdCmIRymaDdXbnQX2gBHpf+cXVpOpbhqXzN3G/Al7053uXvFdZbfq+mk/g+2OaR5bVj67nPlxd207FdHauK9jHtulGfG53lTC7nS/xW+bQSHULbY3LWmD1XRbC01Co61n6HLM0UWX6H+mzw+E60ex8cQH12VptHx543ls/lRRW4pOqZX/YpMkcuAAgA/p255Dt08WbRPnlZK9GeEJOK/p/W/M0LcTNnzozMmXlPu/eUL18eoaGhuHjxIkqVenePPXr0KBITE+Hj4yP6lCpVChYWFjhy5AiaNWsG4F0G0IMHD1C+fPmk7U6aNAnPnj1Lkp8OHToEBwcHFCxYkO7P5cuX4e7OZU2GUU9aFEVRFOVT4lNNefb29kadOnXQvXt3LFq0CHFxcfDz80Pr1q2TMoceP36MGjVqYM2aNShbtiwcHR3RrVs3+Pv7w9nZGQ4ODujbty/Kly+PcuXeNTitVasWChYsiA4dOmDq1KkIDg7GqFGj0KdPnyRJKzAwEJ6enihUqBCio6OxbNkyHD16FAcPHvzgz2HUk5ZFyz+HmVXKJ2K3B/LCs6GPed5/YipHYtFaubvxljC+gGjTbTlaMNBLfuoBgDb2vAx8kwJVRfudYby765z2LUW793O54yoAHFojd/sFAJ9pcp2DTZf5k7BDad75NaufXNckLjO/amMHvBLtz37iNUMebqRDsGoo293M+OLdk+vl7z1v91vU58V0Tzq2eq5ce6P60QHU52FgPtHu8YqvoLT65T4duxog75/ZG67OO+3j3ZJ9l8sl2E+MkDs5A8D9FvL3niGIl3rfW4V/761/km+IG7vUoT5WGeUncvOGPFJmkcoCht+Kfyvave15tHNsPn6M8heQo5PBF3NTn89d5RYNQf7yfQ0Ayo/lkefr4+aL9tLLeaGpFh5ywsD2WdWpj7UTT5zIZiF3qs9+OFS0xyfEgFTMSXs+0ZRnAFi/fj38/PxQo0YNmJqaolmzZpgz54/2C3FxcQgKCkJU1B/35lmzZiW9NiYmBrVr18aCBX/ULTIzM8OePXvQq1cvlC9fHhkyZECnTp0wfvz4pNfExsZi0KBBePz4MWxtbVG0aFEcPnwY1apV++DPYNSTFkVRFEVR/hzOzs6pFpLz8PCAwZB81mRtbY358+dj/nx5sgoAuXLlwr59++j40KFDMXQo7yn3IeikRVEURVHSEu0flG4Y9aQlwQqAoD7c7CsvYLxxnYeS8zzlhXsaLhsi2j2X36M+mQrKpbgLLeESUNPiPGx9d3B+0T6/7RLqM/ayXGPD4YkcYgaAF9GplBD3uCja44vx8P1vM/kxvzbQSbQHVJVD6gAwdktr0Z7jJF9oF1KaL6ptOkDu4L1vLA9b+gyTpY/HHVNWlHzPo95cQ+hTSf5MltO51LNzltxR9/PBPKy/+zJ/Eip5Wl6cusV3KfUZPqMZHVt/We7mnNWOnys7qwfK7zNRPj4A8Oxz+boAgC2l5XPi/gr+i2JnI98HYvfzhY7F2/MO8fUryYuz62zlKag/deOdsF8XlCWTvJt4C4nwXHIdmSLLea0Y1xC+Ujjf1l6ivcBSWbIBgNVj5IWedmb8uoi34WNj+8n3tmN75fM1/E0CMvJTJU35VNe0/K+gFXEVRVEURTEKjDrSoiiKoiifFJ/wQtz/BYx60mISD5gI0WYLKzm02avQT3RbK534iv3oB3IGzE0/D+oTn1Heh+ORXtQHtjZ0yPWCvL1sXcKpz6Pacih54je89P/yB7zoRNOKshzwujzPtbfw4BkAW2rKnXNHdu5Bfdxt5Toto1espD7LQj6jY6t31hDt52bzmj4LQ4uI9odWuajP2No8a2xsRjmFyRDFA6E978myw5Pq/HgX/o534bUIl9+rUWQf6mPTmWeGOWSUpYJO449Tn6ZbBor2/GG8AHvgV3xx4Fl/udP6miU8487pF1la/nIxX7yYw4LLrb3rEAnmcy79ZXYNo2OvystSZ681/PzyPynLa2bPeB2gDMd5ro3XGbmWTfnDvFbSdhe5HotXqCw1AUDBUTzbzeeQ/F6t7sjXc1xkLABeyyYtUXkofVF5SFEURVEUo8CoIy2KoiiK8kmh8lC6YtSTlmxrrsHcJGWoMq6e3K+htt3voh0AdiyRu6cCQFgjOeR+pamcwQEA30bInXs3tObvY3h8k449GCxvzyyVM9zbX+4svDaaF6IqcuYpHbuwKIdob59zL/VZupBUbwMw1E8u0+0wnreGvv1SbguwI5QX+vvpCs9gWtxGzjbo9aAu9QltYyfaw8vzPiGVbXixusI5n4j2Jq5yp2QAmLFClurseaNpON3hg+FE2YrNzrdnxuutYZCX3El5wo7m1KdgOfkYxWfgsumk+nLZdgDYd2SraG8+aCr1aXxFzkqZP0gu1AgAVrvP0bHob+UCfG8ac2nt6RV+Hnn5y202/L9pS33ybJSl5ZaLdlKfHQvK0LFYD/kaPDiG31dOX5WLVtpN5llPefeG0rGDE2TJ962LLB4kxP59ZfxVHkpfVB5SFEVRFMUoMOpIi6IoiqJ8Uqg8lK4Y9aQlpmQeJJinXE3/4JkcDu3/FV+pfr8zf5/s38sBqcareJbL4k1yl9SptZyoz6LveJi59zw5XHsumneNjisp96cpN+cC9blQXpY+AMCkvlxga1ptXhTPjkf2MX6uLM0cDC9MfUbl3CPaL0Z7UB+vIbyQ14TvGoj2yG08IyrT/VOi/XkvWT4DgGoHeNG3X+vJPWAaXOPSh3kluQeTzaaM3CeKZxZlXSZLp9ns+fmw4wKXBS+S5Jg8G3hmTFCsLC/EjueZNt5jn9Ox3Dvk63N1HV6QMV9GuS/Xywi5QBsA3JlWno7lmSZ3GL/rzyWg/LPu0bEH3b1Fe3OfM9Tnlz5ykbZujrzQ5coKvGN5SDn5V7XAQvmcBIAb3eR7R/4hIdSn1gHeAfpgIbnfmWNZ+XwwjYwBltPNpS06aUlXjHrSoiiKoiifErqmJX1J9zUtkydPhomJCQYMGJBki46ORp8+feDi4gI7Ozs0a9YMISF8xq0oiqIoipKukZbz589j8eLFKFo0eTGngQMHYu/evdi6dSscHR3h5+eHpk2b4uTJkx+0/Ye1LWBqnbJAUp7ZcgGyest/pNtauo5ni7zNJNvNYuUiSwDQfILc0dIxlIfoO+zvScdQQJa81pfnhbKefilrM3eiyAcC4PkjTwm53U8es8nIP5OhHM8O+CFCDnVfDuUpK142cqbN7s/l3iYAkLCT95Xann+9aO9q1ZT6PDKpINrN8sqZIgCQrw+flDfc5ifabZ7z7yJukjz20pv3a0k058XEPA/K31NULTnrAwCKLea9a+zvy4+LO/dMpz5d63YV7aFFnalPswNn6djEH2SJY84TX+rzeebLon3DGVnmAYBy3/BMoJOZ84r2All4lp7tFt73J2e7h6J9e2Z+/lsPls+Jek34d9trDe//tcpPPq53xvMeX2ZB8j5MPsyL9g2r25GOVVtzSbQfOFtMtCe+/fuyh1QeSl/SLdISERGBdu3aYenSpciY8Q+dPSwsDMuXL8fMmTNRvXp1lCpVCitXrsSpU6dw5gzXZRVFURTlU8fEYPjoP4WTbpOWPn36oH79+vD1Tf5Uc/HiRcTFxSWze3l5IWfOnDh9Wi4vHxMTg/Dw8GR/iqIoiqL8u0gXeWjTpk24dOkSzp8/n2IsODgYlpaWcHJySmZ3dXVFcHCwuL2AgACMGzcuhd0y+xuYCb1obpHiX4u+5RJQzuNcxjC/RVbZW/OwcJiHnNWTYwAvIGeYK2f7AMCz0vL88sZXvJdRlovyjH1qjt3Up/E4WdYCgIIz5QwT06pcfnnSK5Wib7Plfk/PSvAws4OfLPElPubh9i+yy0X2AKDcxkGi3SwXlwPy7JND9C/eclmr7Y/76Ni64rKs9KhvCeqTeELOPvmqg1xQDQDG/NCEjt1ZL4fVPVxlOQ4Acoziso3pZblfUPVcQ6hPLrNQ0T5onCzhAcCKcrwImkcpuZheraq8yOS6x7LMYu4qNDlLgmdEWT6QJWTr3FwCCo60p2P2DvL23E5xifZpRfnecasVz4iaOa8FHct6Te4JZHWa997Ktl/OymqUTZZGAeDMwdl0rNc9+VzO9oMsQ8XHmUC+atMBlYfSlTSPtDx8+BD9+/fH+vXrYW3Nf3w+hBEjRiAsLCzp7+HDv+30UxRFUZQ/zfvsoY/5UzhpPmm5ePEinj17hpIlS8Lc3Bzm5uY4fvw45syZA3Nzc7i6uiI2NhahoaHJ/EJCQuDm5iZu08rKCg4ODsn+FEVRFEX5d5Hm8lCNGjXw66/JiwJ16dIFXl5eGDZsGHLkyAELCwscOXIEzZq9658SFBSEBw8eoHx5XqRJwvInB5hZpozmTB6wWnz9+IBOdFvmd2VpCgBiN8oRoztP5IJJAJB7qZzdcdZbziYAAEN1HuLNdlCeX1pE8n4yZtHy9tr6yZIIALxoIGdeAUDLzHLxuwWZqlGft+W4zHKvrPyZzMwjqM/kUR1Ee9g6nrkz7EgROla+otzLpXEm3vdnlbn8eR3ucpls4iZeKM6Z9LZq1f4H6nOihK1oH+fMe/tsaxpIx0YWriHaI7bxc9zSlt8+Hg6RpS3P5feoj8FJlnWXN61HfWZf4hXD+raUi0lub16J+tztIGfW5XEMpT4nf5YftgCg0GdyPyVWJBEALMGv6S8LDxDtTnu45BXjKBdrdO10j/o8uelJx/oel/tKZTbj1+3X+9uJ9ikVeZZSRw+5vxAAmOVzFO22QfI9Kt7A72tpjspD6UqaT1rs7e1RuHDyiyRDhgxwcXFJsnfr1g3+/v5wdnaGg4MD+vbti/Lly6NcOXmNg6IoiqIYA1pcLn35Ryrizpo1C6ampmjWrBliYmJQu3ZtLFiw4J/YFUVRFEVRjIS/ZdJy7NixZP+2trbG/PnzMX/+/I/arnNQDMzNU64WH3pZLgyWmIdva8CxlJlO7xmzR25Lf6HVTOrTZrbc98RrES9yVHm9XDAJAJZHVBftzr/yrzC8nizNZF9EXZDpDM+IKlNHzgC46edBffKN5NknN3rK/X2ut+c7WOInOeSfawjP/go8ynvNNJ8tZ7OEXJH74ABA090HRfvSRQ2pT8vGvLDhhTVy1tiRoVzGeNNVLhR3ozW/pvLs5ZkaWZrJ51EmSzlTBADij1ykY+Yl5AJ8Cdl5YcPXXnI2y8ua/JqxSuWx1OyunFF29RsP6gPIMkLXrTz7600iTzhYOkHOcmlVl/ctS4jm1/TCiStF+4/DeBbhUXKbWpN3G/XxNXAJuc+eLqJ9ct1N1GfmgVWivdG6wdTn/H1+f23RUpZ8bywtJdoT30YDftvp9tIUlYfSFe09pCiKoihphMpD6YuJwWB85ffCw8Ph6OiI0s0nwtwi5VPOyInyQty+P8qLwQCgwFz+pP58AlkYt8uF+mRuIz+h3j3Baxk43uZfxY+T5E7A+6OcqM/gs3KtBZfD/MnwxCS5OzUAtLwtL4j0zy5HHgCg6zbemsBzh7xY+UVReZEpAMwcLEdh/H+Xo2EAkNoZ7jZWrr8RO5Uv7I1ck020O9zlEYHHVXi76+jM8kJc6+c8uW9R14WifXSfL6jP/Rb8QCytskq09/yuO/Vx5ms/sXuiXK6/4kb+ZF3QR160+ut13sncaxCvwXN3iNziolszfr7GGeTz4VIY34fwofL5AAB3msjfu20+Xtsl43LeWftpOfk504Kvd4dNRdK5+h7vCO5T/BYdu7cwv2i3fs0XENueuS0POPFM0MhF/HzN4yB/pp/uyuH0xKho3O0yCWFhYemWffr+d6lUy0ligsifJSE2Ghe3fJWu+2rMpHvDREVRFEVRlLRA5SFFURRFSUNU4kk/jHrS4nT8LsxNU5a1vhObRXz9IV9eFvrzO7y8eMUsV0T7/DG8Q+nnDeUOpbFf8vLdLzPwUuGLQuXFmoGneMda/4pyGHxLZnmxGgAUOSkvsgOAzI5yHYbJPnKNDwCw6ci7DoeUkWUgm5f8ij8dKR+HzA3leisAMOUe7wQ8wqSbaDeZxOuTvCRlQywi+SLmhFSixc0+k2tL5LPmtYNymMvylduoO9TnzeoCdMyhmixtrWrOs/pcWvEu1PWuyB2bc2/nMuxrUgb+mym8NUHmK7wPWffDBUX73mHyonYAeFBLDj53qsYXUp+5ymuA1AiMFe3H9xWnPhYDeMVvP/dfRPvcXfWpTyHHV6I983De+uJ5WVkCAgCb4fLi+iehcu0UAHDqI7d8eHuQX2f7vKbSsa43W4t2++PyYu6E2NTaMKQxBkPqmvSf8VcoKg8piqIoimIUGHWkRVEURVE+JTR7KH0x6uyh3GO+ganQlNGMJHE43eRl8i0j+NgDEnl1uMbnfNk2yt2cwyvzYjFzZ3D5angrOYvj7uc808D+gWx/VZyv8q9YPIiOnfxFDhm3LCvLGwCwc5dcrwMASKIG8iyQs0gAYOQJuV7GzVheSn3OnGZ0LNRHLr2fZ8WHXxbb18sZPQDQqHMfOva8uNy515QriXC8Iw/a7OW1UzxOc/kqIOsR0d7smhyGB4B71+U6OwDgllfO7gg7IUu3ANC+tbwPO6ZzOcfl0ms69rSqLElkOc9TbRKt5ZPS8oEssQDAqwr8OIwau0r2SeDX7dHX3nRsUY6jor3pzc+pD9rI97brwz2oS4FloXRswu61so85v4euDJfvHcsXc1nLKoxfg6H5Zdl5diu5rUPUmwS0KHb9b8keKt1Mzmr9s8THRePCd6M0e4ig8pCiKIqiKEaBykOKoiiKkkaYJL77+xh/hWPUk5ac+yNhbp5S6rCdImddWNbiskjoYF4gqsBCOTvAcg4PGXt0kItH7T/Cs2lGlqxDxxILykGx6a3kQnoA72q9ujYva9/pmJxN8//aO++4qM7l/39YYOnNAtgoVlBjCSIS1BghttgitsQktlgQVMRrosmNmJsosbeoGBPFgtHYjcaKiolRVBS72BCxACpSpe/5/eFPcrnM7FcDBFfm/Xrt65XMs3M4+5yzx2dnnvkMwHea9u10mvU5dp5vghk2fy5p79ZgDOtjb0BXn4xcyaeACvhLC3U8nTJJasX7BI6g5c+5EDgA5FrzX7X/jFpD2usZ0ikWAAgaTM9R0hgP1ic5jB3C5rG3SXvCuZqsz/iue9kxO0P6/v/iPn+d1q+lq9CyWvPf26pb77FjHYfSKdp9ZvwcOa6iRdXiRvLd2fv15SuLlri1Ju3+0XxK9fhBuiszAGAonR66nshX4QQfoTtK/3SHTxemNtWS+tOnU6q+ffkUaL3FdNq5xpFU1ufRDD4/6vw1fe5z99ECogUFOQD+wx6vTBEZ/3JF0kOCIAiCIOgEsmgRBEEQhDLiefVQaV7lRUpKCgYNGgRLS0tYW1tj+PDhyMyk9beek5OTA39/f1StWhXm5ubw9fVFUlJSsfeMGzcObm5uMDIyQosWLcjjnD9/Hu3atYOxsTHq1KmDWbN4HR5t6HT1kE/NUTBQEWHCAiasaGnBHvP+XLprLgCkPaT9bE7xPqoedGi/oJBfJ2ZdpqsdAKDaOaY/zTBeICr+Ch3idZnLh9RjJ2hJky1OIu3XR/Ch5C96b2HHvr/RgbRnRfM9neouoUP+WR7OrE9Cfz7M/JNXGGmfOJvvmdRs8EV2jOPiY766Kb+Arlj5wy2M9fkysR1pb2/Fi+x9te4jdsyIKcLJ78D3yMFJXkys58BjvB/DzyfptM3pbgtYH68wvpfR0cGzSXtCIV2tBQAfRtG9m2r9xH/X7w7jxeVqr6T9MsbzongfOPHp1u8j3yXt/T15AcXPqx+n/47vKNbnxgd8/69GM2+T9n6Hz7I+y77rQ9qb+l1gfRL7872RrgTbkXZbe/p+LczKxZm+8/6R6qHWPb8pdfXQyZ1flcu5du3aFQ8ePMDy5cuRn5+PoUOHwt3dHevX80Kpfn5+2L17N8LCwmBlZYWAgACoVCocO/bXd3zcuHFo1KgRoqKicP78ecTExBQ7Rnp6Oho2bAgfHx9MmTIFFy5cwLBhw7BgwQKMHMl3PKfQ6T0tgiAIgvAq8arqtFy5cgV79+7FqVOn0KrVs017ixcvRrdu3TBnzhzUrFly/1paWhp++uknrF+/Hh07PpMeWLVqFVxdXXHixAm0afNsz+KiRYsAAA8fPsT58yVVm8PDw5GXl4eVK1dCrVajSZMmiImJwbx581560SLpIUEQBEF4xUhPTy/2ys2lN0C/KMePH4e1tXXRggUAfHx8oFKpEBVFR+qio6ORn58PH5+/2sW4uLjAwcEBx4/TETzub7dv3x5q9V9Rzs6dOyM2NhZPnvBaSxQ6HWlRsp5C0SsZ+t9xmd5h7z57LHusKLdF7FjvbnQfoSxnPt308HQ10m5zla9ny3yTX2KbJtIhaGUmXzVg1oJek95bxAtbbWu+gB37NGYCaTfii6hwOtOJHTv55gbS3vCGH+tTZxctDPZVjXmszzvhn7Fj04cOIe1PeT0zHItsQtoNM7RUhn28kR0LWTWAtHfQp+87AFCH06Hz2FsurE9efy0/4TT0ua9osY51GXGOrxbZudGLtNue0ZJKMafv15TO/HlP9N3OjvX3o+/Xux35PjSN5twm7V8doytwAGB6fHd2zHfRGdIesoWvojKtS/crAgAU0tcpsBqfjvvIox9pvzOcfw40/IpP2zgeoq/h9J10CggAPv3XQdK+7wHdHwoAbgdrebbZ0H2vCrfSPoV5jOJoeVBG1UN16tQpZg4ODsa0adP+9mETExNha1tc3NHAwABVqlRBYiJdcZuYmAi1Wg1ra+tidjs7O9aHO46zc/EUvp2dXdGYjQ2fCvxfdHrRIgiCIAivEmWVHkpISCi2p8XIiC7znjx5MmbOnKn1mFeuXPn7J/SKIYsWQRAEQXjFsLS0fKGNuBMnTsSQIUO0vqdu3bqwt7dHcnJyMXtBQQFSUlJgb08XCtjb2yMvLw+pqanFoi1JSUmsD3ec/604ev7/L3McQNcXLRpaerB3RzrcvmBPKHuoPs06s2MJK+iQ7JzmYazPYm9aKE4x4QWdFoeEs2P9jejU1prufL+bT9fS4ftJjQ6zPp/1GsaOPR5C2799j07zAMCqRk7sWP2VdD8l+5N8mmW/FR1Ojl7egvXR68T3mpkRRvcqcTfiq0XmPaErlSL6vMn/nZZd2bEaUXSuetSwfazP/X/T4dTwuVoECo351KTDfjrcHtiG/i4BwBvvXmPHUifRVWi3A1kX1PsPfQ7DA4NYn6ZfnGPHCsfSFXx6Kfw/BIU16bTux5sDWJ9579PigAAwPoIWO3P2uMv67BjYnh1T96VTaL2+4quozMLuk3aHf/Olru3+TGbH9k15m7Sb1tfyvU2k+ykl/sFXK574lK7+AoChLeheS9NO02KbWRkaePM6nGWLojx7lcb/JahevTqqV+dTac/x9PREamoqoqOj4ebmBgA4dOgQNBoNPDzoyj03NzcYGhoiIiICvr7PUpqxsbG4c+cOPD09X/gcPT098eWXXyI/Px+Ghs+erQcOHECjRo1eKjUEyEZcQRAEQSgzXlWdFldXV3Tp0gUjRozAyZMncezYMQQEBGDgwIFFlUP37t2Di4sLTp58pthsZWWF4cOHIygoCIcPH0Z0dDSGDh0KT0/PosohALhx4wZiYmKQmJiI7OxsxMTEICYmBnl5z/Znffjhh1Cr1Rg+fDguXbqEjRs3YuHChQgK4n+QcOh2pEUQBEEQhBciPDwcAQEB8Pb2hkqlgq+vb1G5MgDk5+cjNjYWT5/+1S5l/vz5Re/Nzc1F586dsXTp0mLH/fTTTxEZGVn0/y1btgQAxMXFwcnJCVZWVti/fz/8/f3h5uaGatWqYerUqS9d7gzouLhc3a9mQN+4pIiPPh1lhlUc/1GtL/BlVy3W0puYoia5sz6Kig6VzgjlU1QfbeVD0GpHOpTrNCSO9dEzoQWOrgfxPXIazOND/ltj6F4zbaeOY30sEvhKiNsf0HalgA8zu/6LPj+7ffy1VWnpQHZ1Pt3nJakHX144p/Um0r73STPW59Dh5uxYQTVa/M7pF9YF+rl0P574rnz60S6KnweLK/T9330LX9Y451QndkxPRV8Pi2hedEvlTZeh5R3nRRcVN16krUq4GWm3PMZ/Z7CR/h135Tbfg8llLp9mybOlzyG1Pn+dnjTmr5PTLvpeSWnEC+bt+ZxOs9zM5wXkxs7lK8NsrtHf6UdN+XPo/MkJ0r75LJ9S1UoWfZ1qR9D3XUF+DqJ2lY9g23Oe/7vk2eU/pRaXO753armeqy4jkRZBEARBKCNeVXG51wXZ0yIIgiAIgk6g25GW+pmAaclwqePoBPLtK879yh5KH3xKwnNvIGk/t2ox6zOg53DSfjmX3y2/sFcYO7YjhQ6jXujNpySy+6WS9g+cjrI+B8+1ZcdGJ9CKa3laIphPAvjQucu/6TlPaW7N+jgdpNM28X353fMGa3hBM4exdC+jtN2NWJ/vbOhKoP6O0azPrEG04CEAtPqD7gEzZSnfD2R+b1qczCyBD0s/bsKLqq2YH0ba+33PV6WcHz+fHTuYTfePWl6brjwBgHu7HUl7rTl/sj53Nr/BjnEkfFyfHTtYj06lrKvO/53v//UOO6ZOoNNAeTX5tGnDpXxqMr4HLWiZV5cXT3v7zzGkvf7nqayP8Vv8z/2kVnQayDSJ9zk6j65OWfn1ctYnQ2PCjoXepe8jJZjeG1Cg0SLYV9ZolGev0vgLLLq9aBEEQRCEV4kyUsQVaHR60TKzxVaYWpT89bigbn/y/T1n8HLuKW78r/Egr/2kvcW2QNZnx9YFpH1oCF/iNSpwOzv2luUN0n68Br/BM+LNH0n75/d4zRDrA3TkAQAe3KJ/CVt9y3eadqtKR70AIGqmE2mPbMZHsN5cSm/6tfLiv+muxrwkeUMzunN1lEM91uf3ZrQuh9tBfiP1Ghv6lyYAGJ2lN2tOPEXr2ABAAaOYXuDKa9I0sue1NyxU9OZPhzB+Y3azJvxmTcsY+te4+V1+k6nz2FukPaljA95nEh+V0Et9TNqzh/HtNz7uT0cl1v6ylLQDwJ6VHdix3Cr0hmn9Y3xkN9OZvh8AwGkG3RZAZc773Pajo4Yf7uNbE+hr2VhhrEdHLaZ/x7edSHei7X5r+G7qDvufsmNeoSdJ+5rF9PdM8zQHoBt4lzl6KOWeljI7k9cT2dMiCIIgCIJOoNORFkEQBEF4pfiHFXErGzq9aGmufgILdclgUexoejPit+34TrtzlvBy5bda0ps8XefyaZFLnWldh5Q2/IawjmZ8amYII2W+dh6/GfK9aZNIe/1hsaxP9ga+86txIB2KN/uc3zB3fDoteQ8AtSzSSPsba3ndl+o36fSC2V1+I2LsbFqLBQAO96BD5wZp/KbVQV2HkvZqzAZFADD/kJaUBwCT7XRqcushvj3C+Hu01HtEpBY9mBBeLrtLJzp1WsBngGBVhW/v/eYHtEz9/Fp0t18A6DuQThV0XxrF+qybxmslQaGfA/ub8ameUU9psas2u+mO0QCwchWdhgWAwIX0Z1Ll8/eXSQqfQlM51yHt16fxmit/eNGbizdm8B2W3zDm07rBgXSexW/WVtZn3mVv0r7ZbQXrE7RxCDt2vI01aa/XnJ67ggIN4tmjlS1S8ly+SHpIEARBEASdQKcjLYIgCILwSiHVQ+WKTsv434+tDUuLksGidtMCST+73x+yx8yvxu++N3hM72LPdrJifZJa012CJwzczvqEfU13LgUAPVq9G2nOfLCsVmQGaX/zh/Osj50hL4u+9yO6q2e/n3kNkm2JLdmx+xvp1NEPny9kfa7m0m3Mw1vzKSBNAwd2zP3HGNIeWI1PSXRYTGuXZNvxX6WGwRfZsa5Rd0j7YEs+jdfxazpdmNKMTy3M7sLrvtQzpL8bhVqCsRPH8rmjHGs6/fHTt/NYnw1PWpP2vd+3Y300Wn522W+i5y/9bV6nJcOBPm+jd/lnh0kon3aL70XfE7X28emhftP47t4WTI+S1Z9peXYwt+XDIXx1TuElXnzJgMnE1viD6Z8CQH2TrtLLcKfTXQDwoC1/76md6Wdb7b6XSXuBko8jyrZ/RMa/XYdgGBiUQsa/IAe/H/laZPwZJD0kCIIgCIJOIOkhQRAEQSgrNP//VRp/gUWn00Nu/b4lu2laxNFhypSmWlJAOfw0POpGx0MXe/Dh9sXeXUh7aii/TjQ24AXujAfR53AlhE991NlOB9JMEvkwbo1F/B77a6l0FdXjDC1iWLP5edW/nUjab4/kxcRq/kHPw633+cqdRsFX2bFbP9Dzd7XtWtanc026Qid1MJ0+A4AnLrxklJqOdCPXhp87jZoeq/E76wLz27zw3N1OtOBaId+MGE4zY9ixgtYupD2zNn/AJB+6ss76pJaOyG/y35ld7y4i7eOH8SKACSPpPKxZJH+P5/NadaiznE5XxE3gK3fybPh/tY6+P4e0X87jU1SphfS5fzf/Q9ZHGzlM021tVS+1jtCpqH+vW836+MXw5+c4lu5KPuvPLaQ9M0ODt5o8+EfSQ+3bTS11eujo7/+R9BCDpIcEQRAEQdAJJD0kCIIgCGWFVA+VKzq9aLG6lgED/ZIh5UJzOpz8qDVTggPAJZCv7njYhRYge8eYD7dPnEvHjAvO8OE+h7182gaMENuY1kdYl8NT6fOO/5juIQQAva3o/i8AcG4NXaHzTSCfJgu76caOJQxhhN1apbI+a0fRYlTD2/GhZN8TfHqosxndf2ViIt+N+IOrtHBaO1M6dA8AAy/QgnQA4FKF7gnkbx/B+jQypFMpbua8MJ8xX+yGRrY3SXsfO7rXDQBM1+vHjtmdpr9rye5aKqyGx5D22FC6wzkA2B3lH2GDLkwk7VFr6LQRAHjMouevxm5ebO3KVLqiDQBq7KPnIeV7fh52h/AVVj3/RVeuZdbgg+a/TphF2p805tNQf/aey451C6FFKzP5QiDs3EQL8Llu5VN12ihYSz8PA0bT168gPwdA8N/6Wy+NKOKWKzq9aBEEQRCEVwlRxC1fZE+LIAiCIAg6gU5HWh63sIK+uuQubcvbTH8fFb+EVZnxvTv0Eumd4C2X86H41UPpEPSwKN6n0IS/HJP3byPt33XkRaU2nviFtA/weJ/12XChGzv2pBddqfGWCZ0uAYDQN/uyYyYdacGuT+seY316XxhC2nN70pVNALD0Bp/q6d6cToucfMin0PYc8yDt4W/zKYT8/dXYsWON6MqPxA1836aJq+iUXJ2d/O+QBB++AubHNvT99XGz91ifeia32bHeB2NI+5ove7A+Kpd69IDCV15VjeJF397cSIvLNd7MpySm+9P9nmZ6d2J9nBfxz5UTHs1I+4Zv+BTQjGReTA9D6M+bcY8p6QGQD3r+ah/iz/thD178buZEOkU77cvhrI/nmY9Iu8sKOs0DAMr12+xY3q/8973CkfRQuaLTixZBEARBeJXQ0zx7lcZf4JH0kCAIgiAIOoFOR1rmT1oGc6L30ODQ8eT732x0gz1W+gYTdmyx00rSPub3j1mfukx1R81Zf7I+GR+0YcdCmrcl7ddC+bCwuYpOa7134AJ/Dprr7Nj+CXSaZcSCYaxPzlxaBAoAUp7QFVZtTPgKpq1fdiDtzj/wVS7xvnxq5n1PusLksS/fl6Xu1sek/WYT/lrUvMFXrhk/oUPxltPvsT5TFtCh+IKGrAssHfhrMfp2L9L+/rFLrE9YPC+mZ6hXSNoz6vBph9SP6X5djuZ0dRUA2K95xI7tWUqnWfr58d/BXma04OG0c/y1jfOlPysAeDSjU1S9Ivm+TcjkH8v6NvRz5VKXJazPrQL6t6lRwH3W58MldG8rAMiuSacv6m04zvoYZtJ9pa5/wt8Ppvf5vmUZ8XSqWuVDz50mxwA4wB6ubJH0ULmi04sWQRAEQXilEJ2WcqXM00MhISFwd3eHhYUFbG1t0bt3b8TGFv+1kZOTA39/f1StWhXm5ubw9fVFUhLdBVQQBEEQBAEoh0hLZGQk/P394e7ujoKCAnzxxRfo1KkTLl++DDOzZ9ULEyZMwO7du7Fp0yZYWVkhICAAffr0wbFjfNUIxdjFfmT1kMG7dBg8fg3fkr7aOaYBDICgLnQo3jXsDuuT403vpppy6zzrM7ttDXZs3ZX9pN3tAC3QBgAHsunLu6v/W6yPxpjv4ZPVmA7fx/Xh+55McNjLjg1uSofOZz9yZ32ujqErYOJ38gJkjlVT2THjEXSI3HpNLdan0Jyuxqg7g++Dk9KSr05rOOoKaY/ZxvenOTl5AWlveexT1qf6Er56KOMQnTpdHNib9akx9wQ7tlFNVz5Nv7SK9VnavgNpf7CcV8Ub24AX4JuQ4EraY1rxKYk3pwaSdiZrBACwiOePd96W/k4bJPLfM7O7fLVUvjmdxu4ztD3rU+hO94FS3+FTa0Z06zQAgEMYk0KuVZP1eehIP4vaeNG9mQDg2GW+B5njVnqOMmvQ9sI8PfBd1coWPUWBXilSPKXxrQyU+aJl797i/0iFhYXB1tYW0dHRaN++PdLS0vDTTz9h/fr16NixIwBg1apVcHV1xYkTJ9CmDb+vQxAEQRBeaWRPS7lS7tVDaWnP6vCrVHm2kS06Ohr5+fnw8fEpeo+LiwscHBxw/Di9kSs3Nxfp6enFXoIgCIIgVC7KdSOuRqNBYGAgvLy80LTps741iYmJUKvVsLa2LvZeOzs7JCbSMdiQkBB8/fXXJezZdgBVIFNrqTl5HKOHvJCRKp6P/xYa0SmYgppVWZ+vH3Qm7QdimrA+NVfSVSkAcDqX7llU/QidsgGAqQfpVEFWFz78XGvRaXZM+ZoWXKuhzwsLLNnMi5NtOUnPUYExv5Y2Hkj3e3JaxKf3roynq5QAYJbDb6R95aXurM+tPvS1sHN/wPrk7bJmx07E0amU2hf4dJNvJ1qsy64eXTEGAEaP+Yqoh9vrknaLtfy11bfh0zbJvnRqJvgqL9pnW5W+L/N/5yt3vvjAmx2ruZ9OeY1Zwt/jE76hq1zM7/HX4mELPtWTk0WPfdVrK+uzyacVOwYVPUemEfw9nt42hrQ//piv/qp2hv8+adLoH43x6/lUtW0YXT136q4D62N2jX+2BSxYR9q9jOnvYEaGBi6r2cOVLQqA0mitSKBFK+UaafH398fFixexYQOtMvmiTJkyBWlpaUWvhAReeVQQBEEQKorne1pK8xJ4yi3SEhAQgF27duHo0aOoXbt2kd3e3h55eXlITU0tFm1JSkqCvT3dLdXIyAhGRiU7Nzt53IGBWUm7gRe9zB1Si9/oW8uA17AYGk1vMLuXpeXXzUJavtshk1+C95pxlh1b8A4dlVC34o+nUdO/yg6O57sR973B6zM8ekz/2nSqyW/oOzp0NjvWrtEY0m5sxP+qrW9NX6f0uvwvtjoOvM7H9KV0d+gGC3m9mlE2tM7Hwb78L+Q1++hOuwDQ8cAE0p4wiNd2qb3BmrTX/5Lf2KhRtEj836db9Co2vI+eN//L2iKBvoamI/nUroppFl67823WJ/zmYXas32Barn/wMCfWp/kwuq3D0wBe68cgm4+0uMygIxa/6POtJZDGR+wcImhNmMg7TAsEAEaB9IbWHK9M1ifZi9etct5CP9uc/W6zPjeX0M9Q1QU6Kg4AIwfvZscmHRpI2qtE0/+kFeblAPiCPV6ZoqCUe1rK7ExeS8o80qIoCgICArBt2zYcOnQIzs7FQ99ubm4wNDRERMRfu/5jY2Nx584deHry4UpBEARBECo3ZR5p8ff3x/r167Fjxw5YWFgU7VOxsrKCiYkJrKysMHz4cAQFBaFKlSqwtLTE2LFj4enpKZVDgiAIgm4j1UPlSpkvWpYtWwYA6NChQzH7qlWrMGTIEADA/PnzoVKp4Ovri9zcXHTu3BlLly596b91L80a+vkl00N1PqH1UyYHD2KPVfUc/3ecd18l7TsuHGR9juaUPC8A2JdOh1YB4PgTPsTb/jda0+TzKnwI9bGG3rQ6+nZv1sdsH68j4/I7rTUSu5BPzbxf8Ak7lv+Q3jT6bacdrM+3l+ku1KbmfNDQrQovV64ZRIfij92jN6YCwJNg+vOmdKSvOQCkavhNha7/oTeBm4bnsD5Po+gH2+HLtCYHALjM5TdX1r5C3+NGh/huupdP8V2op3T/lbTPXduH9TFMo1N/bY+lsD4DPqBTjABw8xP6nmg8LZX1OedPX/cGC/h9dA0N+fTjmsm0TpHr/tGsj/FtPhV17Q/6ujdYyxcZzNpGd5TufZSfu0s9vmfHmubSneqt6/M9JJy/o89P9YBv2bFUn9/E77qCVl152pROQxXk8ynnMkcDMI21X9xfYCnzRYvyAqtEY2NjLFmyBEuW8P0yBEEQBEEQ/hvp8iwIgiAIZcSrXD2UkpKCQYMGwdLSEtbW1hg+fDgyM/kN2cCLtd0ZN24c3NzcYGRkhBYtWpQ4xu3bt6Gnp1fideIEr6rNoae8SGjkFSM9PR1WVlaYcfIdGJuXDBatiKVl6g+5/8Aes+uMSexYDiPHkmfFT129KbQWxLVFvNz8b+/NZ8eWPexA2pua3WV9wu/SmhNf1uVTSoVa1rGfX/Al7Vk3eb0O40d8nPTjQXTb1a3xLVift+zjSPuOi81ZH7UpHxqu8z0dbDRI51MzsePpNJlLIN9F3GwXnx56OpiuoOi3m+9GvGQ2fS0s79BdgAFgxyo+sukzJZC0p9Xnr5/Cq9cjz4qOcbtMucj63A6iU6eFfNYN9dfwqZnCG/S9MvoqnWoFgK8u0t2uB9Tju4hvX/wOO2b7B11Zl1OH1voB/g/dl2r0M8f2DP8ssv6DTm1dDuZl96v/yQfhx0/+hbSvHt6D9emzgk6lL7rEz131tXzri8ya9M2nx6RWCvNycH7lF0hLS4OlJT/3peH5v0veTSbBQF/LTft/UFCYi4hLs8vlXLt27YoHDx5g+fLlyM/Px9ChQ+Hu7o7165nSPQB+fn7YvXs3wsLCitruqFSqYm13xo0bh0aNGiEqKgrnz59HTExMsWPcvn0bzs7OOHjwIJo0+UurrGrVqjA05J+NFNLlWRAEQRBec65cuYK9e/fi1KlTaNXqmTzD4sWL0a1bN8yZMwc1a5ZcxL5o251FixYBAB4+fIjz5/l9kVWrVmWlTV4USQ8JgiAIQlnxvHqoNC+gROua3NzcUp3W8ePHYW1tXbRgAQAfHx+oVCpERUWRPn+n7Y42evbsCVtbW7Rt2xY7d+58+Q8BHY+0LD3xDlQmJStQLGLpj3WuuTV7rGxvvrLCcRAtNGYfyYdxf59JC42ZxfHh9h4bJ7JjhZa0qFTbjtdYn9zVdIfZwq/5terCxi3ZMatfs0l7hgkvsmf1Ni88tz+Rlnq3nMkLTp21otNrn82i5fgBwFqfl6+f5kOLVKERL+xmdIW+7ndW8p2hDznyqcl2w+nU5C/v8wJkjwPp89PTUqXU+2O+WiStA31ftunMp3NG2fHCbmMu0pV690by1XP5rvR1srbkr9/dJvx3MO+cB2mfsp62A0Dd7+nv0++PeLG1jG/ZIdieoL9rW1YuZn36DhnLjhWY0sfTGPLf6ewmdBrIrlYq65NRi68amxP7LmnP68Cnc1yM6Aq+auG8j8FYXmRvbG36H9llN5lu109zgZXs4cqWMip5rlOnuOBjcHAwpk2b9rcPm5iYCFtb22I2AwMDVKlShW2h83fa7lCYm5tj7ty58PLygkqlwpYtW9C7d29s374dPXv2fKnPodOLFkEQBEF4HUlISCi2p4VShQeAyZMnY+bMmVqPdeXKlTI9t5elWrVqCAr6S23d3d0d9+/fx+zZs2XRIgiCIAgVRhnptFhaWr7QRtyJEycWaaBx1K1bF/b29khOLr5xvaCgACkpKew+k7/TdudF8fDwwIEDdDGGNnR60VLlrAH01SU/Qo0P6aoBTyO+tOucZxg79smhTqT9o+qRrM/dFnRFzU8NfmZ93t5H96ABgJp1aIGtU1m8CNqHX9Apky/mDWd9qrzF500bW9Or9ZAufMdavyX+7Jj+LTrldfcD1gXVmXD79Ww71ufMl3zFlkEL2p4XZ8b6WNHahbA6wndY/jiHT80MDD1K2remMqFuAA1W0ykTRZ9/Wnp+f4odO/iA7iP0Rxx/fx3f35Qdy3Ok76PZfnR3XgD44sz7pD3lBt/leXuvBexYr1T63lMn8JUdc0/TefYxI2hBNQD4d99N7NiGNXSKr9Vh/nvRKJFPVRt/z4z11yKe9gudMoxP4P/RcVnOp53vZtEickZ84RrGrKLF9I4tnsv6eKzl0+U/htIpL/UIupqsQJ9+1pQHpS1bflnf6tWro3p1Pp33HE9PT6SmpiI6Ohpubm4AgEOHDkGj0cDDg06Z/nfbHV/fZxWLZdV2JyYmBjVq0FsYtKHTixZBEARBeKV4RWX8XV1d0aVLF4wYMQKhoaHIz89HQEAABg4cWFQ5dO/ePXh7e2PNmjVo3br1C7fduXHjBjIzM5GYmIjs7OyikufGjRtDrVZj9erVUKvVaNny2Z7JrVu3YuXKlfjxxx9f+nPIokUQBEEQKgHh4eEICAiAt7d3USud5+XKAJCfn4/Y2Fg8ffpXJPdF2u58+umniIz8K/PwfHESFxcHJycnAMA333yD+Ph4GBgYwMXFBRs3bkTfvn1f+jPotLic+/vfwsCwZEje6iwdInxan1GJA2CcRPfpAYD4HtakPWAg3V8FADYHdibtD7z4agcthR9w2E+LnT1qxqckNIz4V+2d/K58xZg/iWtT6JRJg7l8SkkzN50de7yR7uGj7s0Lhll0o3uV6NvwAne3AukqJQDw7ERXxyT68/2UnjSmq6UeufFfJYsbfHVHnjVttz3LVzCtC6X7yYz0GcL6xA20ZcccdtNph3wbPpVidJKuqgOAG1OakHZ9XrMPeXXpwZs+q1ifzlf5/jSqifR+AMvF/P2V+llt0j51HX8OHx0cxY5ZX6R/F47y48s9F2oRXHMeTucmjX7lnwOpIcy9rOJTifFd+TGf1vR35g1zXuhyyRb6OtU6yueUFv3IV1hNGORH2p80oquRCvNycG7NPyMu51MvsNTicgdvLijXc9VlJNIiCIIgCGXFK5oeel0QcTlBEARBEHQCnY60+E/dBFOLkjmQhwV0SG1WVBf2WFWOWbNjzTvTvUrGWPPh0F0JdFqk6kW+EiLNiV9DfhBKVwJtGNGV9SkwofNDqe58pY119EN2bE87ul19qhcfCg36VwA7Znc+ibRfe5sPidb6nU7xpU/i+6gYpbJDmFN7L2lP3cb/2nn34HjS/pv3ItIOAIuSO7Jj+/5sQdozavJfz/ZH6GoWVTB/3qOa7WfHfmxC9+tSFL4qxSnLmR1rMJeuPrnxPS/A5/IZXSFXt5Cvduvfgu7xBQDpP9Apk2n2EaxPb0e6YmXi1f6sD9fvBgBMk+jBfhZ8dc7iGF63oueJm6R95Sy+78+jXnTlzG9dF7A+/c6MYMfudaXn9a49L9rXcx3dGG+LJd0fDQDmJdIidgCwJJzuoxXYaTBpLygsnZrsy1HKSAsk0qINnV60CIIgCMIrhaSHyhVJDwmCIAiCoBO8ltVDqfXotZi2MC7X8h0A9J3pyqKjbZaxPl1i6JC21VK+T098P/4cqv5JVx097cpX59St+pi05xTyAbaC2bzglOnke6T94RpH1sdzTDQ7duM9a3pASyXQgn1hpD25kO9h8nNKG3bsxhhaKOvaML7XDIzoG0n/IV95Ze7yhB3LL6DTeHnX+TSZwlSGTe2xmfXZ8Bbf96egIV010/2nI6zP3i5vsGNtd9OVRU8L+eq5P6bQ18kohQ/tKyF0SgkAchbSqagWX51lfSK20D3DTPiCI5z6hn8OtLtAC+YlnudTtA1/0PLHNPS9d7cnL9KlaZ9G2mv24aXd477jUz07B9KCcBO9P2J9bg6hnysbPprP+uQo/HMqeBD9fL3fjqkeys1B7Px/qHrIMQAGqlJUD2lycTD+e6keYpD0kCAIgiCUFYrm2as0/gKLpIcEQRAEQdAJdDrS4vvFARibl/wIe/rTYea1e3mBqI9d6P5CADD87HnSvjnDhfVpYPOItHedf5j1mXvFhx2z3RlP2jMe8b1hBs2iK45ytKjY/ad3L3asRg6dMqmy+iTr4zqJrhACgNPv0D2BHnTiRdWGx9Ih6IJVfLhdP5dPuz3xpvMsI7z4CpN3zC+T9g/38P2F7PrQVR8A4HuBTrvNusVfC4MsWvxrQ3e+X9HVqXx/knO+C0n7l4ntWJ+5v//Cjg2eSlfhFBrzomUnf6IrQhqF8/NaeIe/l7v8+xxp37eXTgEBgPPCGNI+6hz9DACAbp34yiLLZDp9ZV6DF4N70oq/Ts5j6UrGJ9/zaV1902zSnjyWT5sO6Pw7O2ahoiMBGU35867unkjazfT47/qQBXwvtloP6efK4I//IO05mQUI5jNRZYtsxC1XdHrRIgiCIAivFBoFpSpb1siiRRs6vRHXdcwM6BuV/MWyOpBeUn/+IS+3rZ7BRwRSQumNpo8b89m16h70L4vkaP4XkeNvdOdeAEh2ozeY5fF7VlHI/JizpJXwAQCP3flfPpZX6DWugQ+94RcAnubwGy/19Ohbr7YvLRMOAImBtJ6IzXv3WZ9fXMLZMe/Fk0i7fecE1id9Db1p9dGb/FfJ9C5/r6wcQ+u7zLrHa/Ccu0vr0tht4jcQWxzkN15yGzxvB/Gbbf/1Ad/d+1wmLR2/bw8f5WjUnr4xL9yow/qo7/ORlgE96e7Zfzzko5PD6hwj7d9sGsD65NnwHYSrnqUjebO/CGV9/NbSHZEBQMP8zDz0ySzWp/e0z0h7tTOprM/2XWv443X/hLRn1zJnfe50oSNszZvdZn2efsY/K/VO0c+Ia0vdSLsmOwcJ46f+Mxtxa44q/Ubc+8tlIy6D7GkRBEEQBEEnkPSQIAiCIJQVCkq5p6XMzuS1RKcXLW/4XoHarGT64eOl9AauY7/QnXEB4Ewer/OR8DUtHf9tTDfWZ7gjHWbeY8aH2zNX8bmeWnsz6YFHvP7H1akNSHv1rfRmPgBIdeE3F9c4nErac67z5/3hrIPsmLtJHGn//AM+jVdjcRRpTzDjdSV21KbnAQCyXOkusxqF3zD6ry9/Ju3GKl7y/rNwWl4cAIKu0Rs51bP5lg+rflhB2hfV5qXP7afQGzIB4JoXHXQt4PeLYss7LfhBfTot4pzMy+43OUnrsTw64MT6jJi2hR2bdZHeXO/sx3c5X962L2n/8OsjrM/Bqfxm5fsdXr581eYq77M0hN4w3eU0/53ZMJXWVUnl8scAmmzi22/0WUlvvL8wnO+mvrbbOtL+rasn67PiOn9tJ93pTdq99On2CPlZeeATvmWMbMQtVyQ9JAiCIAiCTqDTkRZBEARBeKXQaACUQiCO2RQvPEOnq4c6vvE5DPRL7tJ+EkKH6etYprLHbF+F77q69206veD7O1/lErKLlu+uc4CvzjGJT2XHNPF0R+lsbz7d1H/WHtI+5zCf1grocIAdi3i3EWn3PsCnmyLeqceOKXZ02q3uKjptBABxPemUicsuXvp8940m7NjJt34g7SNud2d97oTS90OVw7SWDgDEzuJ1ZA61W0za/d4dwvqoV2SQ9st/8PPdrD0trQ8AZ6JpP4f9/AM0viufQrM7TgdxVQX844Zrs2Fxi0mNApizlU6TAcDqFC/SvvN6U9bH2pxOoe1pxlfTdJ/I64k8taPnIcOJn4fab/Dpq8xf6KqxtEb88RqG0pWRijFfeVV9BV39CABXQxuTdm0aPNVX0WnB1H50tQ8AWA7nEzoDatLH29KJrk4r0OTiYMKyf6Z6qPpwGKj4qsn/iwJNHg4+/EmqhxgkPSQIgiAIgk4g6SFBEARBKCtkI265otOLFlVaBlSqktUfJkvojqfnvXiZ6TN1eAGrwREnSPu68T1Yn70r5pD2AddoMTMASHfkz8+8H53yylnLtPsFsLs7HXqt2pH32VyXltYHgKERf5L24Va0DD0A7GrpzY4ZR9Hpipsj67M+9wfQlUppM/hO03k9+KqeDmeHkPbejrxs+xU7ujO0SRM6dA8ADebylTt+tejqoXhfW9bHoSfdJiJ/Bi90FvMnP68m9elu4fmmfFfy+hty2LFHzehqvNQ3+HSTyzL6HNqFn2F9AkaPY8dSXOn0R9X7/DlM+oYWzOswl25LAAC1rvAVfBY36UdskP9e1mdOaD92zDqZvr6pHegqOABQHtGtBBI/pNM8AHBnJ526BQA9RvMtqzHfjVu/J/39HFefbwUxYw0v6OcxchNp//bLnqRdk50DjGcPV7aIIm65IukhQRAEQRB0Ap2OtAiCIAjCq4SiaKAof78CqDS+lQGdXrTEBtlDZVJSIEllQacDTGL4j1svnK9Q6P8bvVP95jQ+nVNF9fJBLLNEvrIotOF60v6eWxDrMz14F2kPS27L+px9UIsde5BvTdpbTe/N+oAvZsGK5XSl0pBlfBzXJJkOnQbP/In1md+TruQCAL1HqaR9Z+8OrE9WY/qhUusIny7JnpnFjnWvRleurXa3YX3uD6FD+467+Xvo7tvsEDo43CDtJ2z46g6uHxYA1A+5RNqjLh9ifVrGjyXtK/d1ZH0OLJ/NjnVdSffc+cqf7/b+7eShpN2qgE+79f2F79y+diKdrtjwLi+GOPMwfy+P+Z3ucm59jO85dYPpnWZ6nHXBDj9+Xodc+Zi01/HlK/hs9tOpunBfvrO9xayH7NjEenQ3c/019LNfT59PEZc5ilK6FI/sadGKTi9aBEEQBOGVQinlnhZZtGhF9rQIgiAIgqAT6HSkpUrtNOiblgzJhzYJJ9/fL9OfPVbVH/nQ5sT29C72rGZ0lRIAXFx4lLSv+5KuKgIAZwNekEgFutW59RV+3Tn20UjSvnY43b8EAEb/xKdmfrHtQNqrJvApCeNHfFXD+pQ2pL1Qiy5TdnVawKquYSrrk+xVjR1bNoVOu3H9gAAg8xRdPnHjA77S5hvH39ixd01p4cBtG/nQ+ROmnVJGbf4rrc9fCuz9na4a03jwYXXDJF6cbPEF+vM2Dv8X69PsPTpFFZfK92D68HP+eIZMpvNYBl39BQC/zV9A2r0W82nYn0d2ZcdMk+jKndvzrVmfFmraBwBq7aSv7/23+X0Q+99aStoHRPCVjO/u4j+vqT2dSt95lRem/DmdnvPqW8+yPvOnfcCOKa3o1OR6T1psMCtDA76OsYzRaHilxBdB9rRoRacXLYIgCILwSiHpoXJF0kOCIAiCIOgEOt17qPW28TAwK5k2ufeArrpQ8vk1mvohH+r27XaMtG+JbcH6OA28QNrzuvDVGKaX+J4jl/9NC5dZX+SDZZltaEGzhoF0OgIAYMAf70kHJ9KuzuArK+6154XsPu16kLRfzuBF2o5eosPM9of5887wpUXLAKDKGnPSnlqfP++gT7eQ9pkbfVmf93vR9xAAnOtJCxs+fpsXPDT95D5pT/+Fr/5a9sUidixLoXNy/mc/5M/hN74viukj+p54Wo2f10dt6FTU/k4LWJ+eYXyKo8CUfrQVWvD3q8I8IvQz+fP+tvtGdmzV3bdI+/U7fC+qKR50zzAAeNeMrjTze38066NKosXvrnzDp7cPePMp5FGDaUG/vCl8WsusOy1Ambi5LutjN53PE18PoL/v3DNek52DhDHT/pHeQx1NB8JArxS9h5Q8HHq6QXoPMUh6SBAEQRDKCkkPlSuSHhIEQRAEQSfQ7UhLWHXAsKS43IhptNhTe7Or7KHGh/CVRRsjPUm7QaaWNV8EneIwmMZX2lz9lu81o3pC/y0DXrMMpqdpwanNZ3ezPn09+7BjNifo9NXjtnyY2eYyO4TI6XQq4/oXrrzPQFr0yu/bQfw5xNCVVwCQu5D+TK7GT1mfdf7dSbsyihcoHF2FTw+9t3AUaa+6kk9juFgnkfa0oXwqrI4B3xtme6YTac9+xAvI5Xnz/ZRsJ9Hn92sU3dsHANpH08JuY/v7sT72VfjqpoR36ceb6zd8evTWSCfSXncJ3ScLAMI2vMeOXR9GfwdXvLuS9fkylhdDDDdsTdrrLb3N+kQn0mlG00L++vn35dNNdyfRc154nmlKBGDrtZ9J+7KH/DP0hpp/DrRyvkPan0yuTdoLCgqQwB6tjNEogJ5EWsoL3V60CIIgCMKrhKIAKE3JsyxatCHpIUEQBEEQdAKdjrSYH7hI7tIeND+afP/wj+jeJgCweu1cdqzH4QDS3qs9L4y0+Zg7af917QLWZ8g3E9mx/B50BYDt9Eesz89nfiXtbebywlE5s/l8U91PYkn7Yy0ie6O68IJTERvo3k11P49ifcZ69CXt17+zZn2i2oayY0mF9K+abnsDWR/XOFqIsJ4/nx7yCaL74ACAxoT+Vaafw6cS7z21Ju2xkXw1BobSvagAYPl1uh9Vo0C6Cg4A9Jz46qbRkZGk3WsRf+9ZeyeSdofFdCoAAKwN+RTHow20eOHcPzezPu/toM9PyePTUHk2JVPUz6l2kq46mreATwGlDOF7mn3U7Qhpj0yuz/oY7qSrKe1Xn2J9ri2mxQYBwHk5nbZUf8lfp167aNFKRc1HFUzG89f2xnUn0m7Qna7a0eSoAC29lsoSRaNAKUV6SAcLev9RKjTSsmTJEjg5OcHY2BgeHh44efJkRZ6OIAiCIJQORVP6l8BSYZGWjRs3IigoCKGhofDw8MCCBQvQuXNnxMbGwtaW35D636gsLaFSlVxZ+3WgO6G+tY3/ZRH0Ab/Zr/Y0Wn9g8/mWrM/iLmtI+5ixvEx+tQnx7Ni9XXSn1nu0ajUAoHUY/atx7VheryPgaz4atfUW3ZrAYz7/q6ylyW12LPlPWoPg0D1Gox7A8fq07P4bSfQmTgD4T1I7duxaV/pXaO11fIfZm0PoTda7h/CdcX/LpLsyA0C+Qv8a/97mHdbH4DgdUam3PY316ZzCa5rU3k7raMSH85Eb5YwVO/b5msGk3WkvHTEEgNQE+nt/ScM/D47NX86O/XmT3rQ6djAdOQWAvavpiOvsNp1Yn5PhvMZT2IT5pP2D05+yPjXW8huwAz86Q9ojvuLv8aEhdMR1QYMerM8wL75z9e5jHUi7wRS+XcamDd+T9oeFtE4SABxKb8KOuZjQOkXhAfQm+YKCPMSxRytbJNJSvlRYpGXevHkYMWIEhg4disaNGyM0NBSmpqZYuZLfVS8IgiAIQuWlQiIteXl5iI6OxpQpU4psKpUKPj4+OH68ZOIxNzcXubl/lWumpT37NVmgYTrAaeimermZfF66oKBk48WisSy6VFSTzfs8ZVRiC/Jf/u8AQGEu7ac81eKTQ/tkZfDhx8I8/vzSGT/u3J79Lf5XI3c9CrV8JvYcnvLnoPW6M/eQ1mvBzGumlnnNyeL3p+Qzv6y03V+aHNqnoPDl7yEAKNDQfoVP+SiCouV4nLKstvPjvhvaes+la7m/uOMVFPCdI7lrmJfJ+2ibV+542u7XAi3K3dz9r+25kp1J33sa5j4GgBwt3xnuGaHtGcrNw9PCl38+AEB2If2ZuHN4bv8nohgFSm6pUjwF4D+3AECpAO7du6cAUP78889i9kmTJimtW7cu8f7g4ODnEoPykpe85CUvef2t182bN8vt37Xs7GzF3t6+TM7T3t5eyc7OLrdz1WV0onpoypQpCAr6a39GamoqHB0dcefOHVhZWVXgmVUs6enpqFOnDhISEip1jwqZh2fIPPyFzMUzZB6ekZaWBgcHB1SpUqXc/oaxsTHi4uKQl8dH5V4UtVoNY2O+Kq0yUyGLlmrVqkFfXx9JScVVM5OSkmBvX1JV0cjICEZGJVVNraysKvUX8TmWlpYyD5B5eI7Mw1/IXDxD5uEZKlX5buM0NjaWxUY5UyEbcdVqNdzc3BAREVFk02g0iIiIgKcnLZkvCIIgCELlpsLSQ0FBQRg8eDBatWqF1q1bY8GCBcjKysLQoXzpqiAIgiAIlZcKW7QMGDAADx8+xNSpU5GYmIgWLVpg7969sLOz+z99jYyMEBwcTKaMKhMyD8+QeXiGzMNfyFw8Q+bhGTIPrw96iiJKNoIgCIIgvPpIw0RBEARBEHQCWbQIgiAIgqATyKJFEARBEASdQBYtgiAIgiDoBLJoEQRBEARBJ9DJRcuSJUvg5OQEY2NjeHh44OTJkxV9SuXK0aNH0aNHD9SsWRN6enrYvn17sXFFUTB16lTUqFEDJiYm8PHxwfXr1yvmZMuRkJAQuLu7w8LCAra2tujduzdiY2OLvScnJwf+/v6oWrUqzM3N4evrW0J5WddZtmwZmjVrVqRy6unpiT179hSNV4Y5oPjuu++gp6eHwMDAIltlmItp06ZBT0+v2MvFxaVovDLMwXPu3buHjz76CFWrVoWJiQneeOMNnD59umi8sjwrX2d0btGyceNGBAUFITg4GGfOnEHz5s3RuXNnJCcnV/SplRtZWVlo3rw5lixZQo7PmjULixYtQmhoKKKiomBmZobOnTsjR0sXV10kMjIS/v7+OHHiBA4cOID8/Hx06tQJWVlZRe+ZMGECfv31V2zatAmRkZG4f/8++vTpU4FnXfbUrl0b3333HaKjo3H69Gl07NgRvXr1wqVLlwBUjjn4X06dOoXly5ejWbNmxeyVZS6aNGmCBw8eFL3++OOPorHKMgdPnjyBl5cXDA0NsWfPHly+fBlz586FjY1N0Xsqy7PytaZi+zW+PK1bt1b8/f2L/r+wsFCpWbOmEhISUoFn9c8BQNm2bVvR/2s0GsXe3l6ZPXt2kS01NVUxMjJSfv755wo4w3+O5ORkBYASGRmpKMqzz21oaKhs2rSp6D1XrlxRACjHjx+vqNP8R7CxsVF+/PHHSjkHGRkZSoMGDZQDBw4ob7/9tjJ+/HhFUSrP/RAcHKw0b96cHKssc6AoivL5558rbdu2Zccr87PydUKnIi15eXmIjo6Gj49PkU2lUsHHxwfHjx+vwDOrOOLi4pCYmFhsTqysrODh4fHaz0laWhoAFHVujY6ORn5+frG5cHFxgYODw2s7F4WFhdiwYQOysrLg6elZKefA398f7733XrHPDFSu++H69euoWbMm6tati0GDBuHOnTsAKtcc7Ny5E61atUK/fv1ga2uLli1bYsWKFUXjlflZ+TqhU4uWR48eobCwsITUv52dHRITEyvorCqW55+7ss2JRqNBYGAgvLy80LRpUwDP5kKtVsPa2rrYe1/Hubhw4QLMzc1hZGSE0aNHY9u2bWjcuHGlmgMA2LBhA86cOYOQkJASY5VlLjw8PBAWFoa9e/di2bJliIuLQ7t27ZCRkVFp5gAAbt26hWXLlqFBgwbYt28f/Pz8MG7cOKxevRpA5X1Wvm5UWO8hQSgN/v7+uHjxYrHcfWWiUaNGiImJQVpaGjZv3ozBgwcjMjKyok/rHyUhIQHjx4/HgQMHYGxsXNGnU2F07dq16L+bNWsGDw8PODo64pdffoGJiUkFntk/i0ajQatWrTBjxgwAQMuWLXHx4kWEhoZi8ODBFXx2QlmhU5GWatWqQV9fv8TO96SkJNjb21fQWVUszz93ZZqTgIAA7Nq1C4cPH0bt2rWL7Pb29sjLy0Nqamqx97+Oc6FWq1G/fn24ubkhJCQEzZs3x8KFCyvVHERHRyM5ORlvvvkmDAwMYGBggMjISCxatAgGBgaws7OrNHPx31hbW6Nhw4a4ceNGpbofatSogcaNGxezubq6FqXKKuOz8nVEpxYtarUabm5uiIiIKLJpNBpERETA09OzAs+s4nB2doa9vX2xOUlPT0dUVNRrNyeKoiAgIADbtm3DoUOH4OzsXGzczc0NhoaGxeYiNjYWd+7cee3m4n/RaDTIzc2tVHPg7e2NCxcuICYmpujVqlUrDBo0qOi/K8tc/DeZmZm4efMmatSoUanuBy8vrxISCNeuXYOjoyOAyvWsfK2p6J3AL8uGDRsUIyMjJSwsTLl8+bIycuRIxdraWklMTKzoUys3MjIylLNnzypnz55VACjz5s1Tzp49q8THxyuKoijfffedYm1trezYsUM5f/680qtXL8XZ2VnJzs6u4DMvW/z8/BQrKyvlyJEjyoMHD4peT58+LXrP6NGjFQcHB+XQoUPK6dOnFU9PT8XT07MCz7rsmTx5shIZGanExcUp58+fVyZPnqzo6ekp+/fvVxSlcswBx39XDylK5ZiLiRMnKkeOHFHi4uKUY8eOKT4+Pkq1atWU5ORkRVEqxxwoiqKcPHlSMTAwUKZPn65cv35dCQ8PV0xNTZV169YVvaeyPCtfZ3Ru0aIoirJ48WLFwcFBUavVSuvWrZUTJ05U9CmVK4cPH1YAlHgNHjxYUZRnpXxfffWVYmdnpxgZGSne3t5KbGxsxZ50OUDNAQBl1apVRe/Jzs5WxowZo9jY2CimpqbK+++/rzx48KDiTrocGDZsmOLo6Kio1WqlevXqire3d9GCRVEqxxxw/O+ipTLMxYABA5QaNWooarVaqVWrljJgwADlxo0bReOVYQ6e8+uvvypNmzZVjIyMFBcXF+WHH34oNl5ZnpWvM3qKoigVE+MRBEEQBEF4cXRqT4sgCIIgCJUXWbQIgiAIgqATyKJFEARBEASdQBYtgiAIgiDoBLJoEQRBEARBJ5BFiyAIgiAIOoEsWgRBEARB0Alk0SIIgiAIgk4gixZBEARBEHQCWbQIgiAIgqATyKJFEARBEASd4P8BhtX7y+q8bVYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.show_pe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(32)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([4, 10])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = TSTPlus(3, 2, 10)\n",
    "xb = torch.randn(4, 3, 10)\n",
    "yb = torch.randint(0, 2, (4,))\n",
    "test_eq(model.backbone._key_padding_mask(xb)[1], None)\n",
    "random_idxs = random_choice(len(xb), 2, False)\n",
    "xb[random_idxs, :, -5:] = np.nan\n",
    "xb[random_idxs, 0, 1] = np.nan\n",
    "test_eq(model.backbone._key_padding_mask(xb.clone())[1].data, (torch.isnan(xb).float().mean(1)==1).bool())\n",
    "test_eq(model.backbone._key_padding_mask(xb.clone())[1].data.shape, (4,10))\n",
    "print(torch.isnan(xb).sum())\n",
    "pred = model.to(xb.device)(xb.clone())\n",
    "loss = CrossEntropyLossFlat()(pred, yb)\n",
    "loss.backward()\n",
    "model.to(xb.device).backbone._key_padding_mask(xb)[1].data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 4\n",
    "c_in = 3\n",
    "seq_len = 10\n",
    "c_out = 2\n",
    "xb = torch.randn(bs, c_in, seq_len)\n",
    "xb[:, -1] = torch.randint(0, 2, (bs, seq_len)).sort()[0]\n",
    "model = TSTPlus(c_in, c_out, seq_len).to(xb.device)\n",
    "test_eq(model.backbone._key_padding_mask(xb)[1], None)\n",
    "model = TSTPlus(c_in, c_out, seq_len, padding_var=-1).to(xb.device)\n",
    "test_eq(model.backbone._key_padding_mask(xb)[1], (xb[:, -1]==1))\n",
    "model = TSTPlus(c_in, c_out, seq_len, padding_var=2).to(xb.device)\n",
    "test_eq(model.backbone._key_padding_mask(xb)[1], (xb[:, -1]==1))\n",
    "test_eq(model(xb).shape, (bs, c_out))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 4\n",
    "c_in = 3\n",
    "seq_len = 10\n",
    "c_out = 2\n",
    "xb = torch.randn(bs, c_in, seq_len)\n",
    "model = TSTPlus(c_in, c_out, seq_len, act='smelu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@delegates(TSTPlus.__init__)\n",
    "class MultiTSTPlus(nn.Sequential):\n",
    "    _arch = TSTPlus\n",
    "    def __init__(self, feat_list, c_out, seq_len, max_seq_len:Optional[int]=512, custom_head=None, **kwargs):\n",
    "        r\"\"\"\n",
    "        MultiTST is a class that allows you to create a model with multiple branches of TST.\n",
    "        \n",
    "        Args:\n",
    "            * feat_list: list with number of features that will be passed to each body, or list of list with feature indices.\n",
    "        \"\"\"\n",
    "        self.feat_list = [feat_list] if isinstance(feat_list, int) else feat_list \n",
    "        self.device = ifnone(device, default_device())\n",
    "        \n",
    "        # Backbone\n",
    "        branches = nn.ModuleList()\n",
    "        self.head_nf = 0\n",
    "        for feat in self.feat_list:\n",
    "            if is_listy(feat): feat = len(feat)\n",
    "            m = build_ts_model(self._arch, c_in=feat, c_out=c_out, seq_len=seq_len, max_seq_len=max_seq_len, **kwargs)\n",
    "            with torch.no_grad(): \n",
    "                self.head_nf += m[0](torch.randn(1, feat, ifnone(seq_len, 10)).to(self.device)).shape[1]\n",
    "            branches.append(m.backbone)\n",
    "        backbone = _Splitter(self.feat_list, branches)\n",
    "        \n",
    "        # Head\n",
    "        self.c_out = c_out\n",
    "        q_len = min(seq_len, max_seq_len)\n",
    "        self.seq_len = q_len \n",
    "        if custom_head is None:\n",
    "            head = self._arch.create_head(self, self.head_nf, c_out, q_len)\n",
    "        else: \n",
    "            head = custom_head(self.head_nf, c_out, q_len)\n",
    "    \n",
    "        layers = OrderedDict([('backbone', nn.Sequential(backbone)), ('head', nn.Sequential(head))])\n",
    "        super().__init__(layers)\n",
    "        self.to(self.device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|exporti\n",
    "class _Splitter(Module):\n",
    "    def __init__(self, feat_list, branches):\n",
    "        self.feat_list, self.branches = feat_list, branches\n",
    "    def forward(self, x):\n",
    "        if is_listy(self.feat_list[0]): \n",
    "            x = [x[:, feat] for feat in self.feat_list]\n",
    "        else: \n",
    "            x = torch.split(x, self.feat_list, dim=1)\n",
    "        _out = []\n",
    "        for xi, branch in zip(x, self.branches): _out.append(branch(xi))\n",
    "        output = torch.cat(_out, dim=1)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 8\n",
    "c_in = 7  # aka channels, features, variables, dimensions\n",
    "c_out = 2\n",
    "seq_len = 10\n",
    "xb2 = torch.randn(bs, c_in, seq_len)\n",
    "model1 = MultiTSTPlus([2, 5], c_out, seq_len)\n",
    "model2 = MultiTSTPlus(7, c_out, seq_len)\n",
    "test_eq(model1.to(xb2.device)(xb2).shape, (bs, c_out))\n",
    "test_eq(model1.to(xb2.device)(xb2).shape, model2.to(xb2.device)(xb2).shape)\n",
    "test_eq(count_parameters(model1) > count_parameters(model2), True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 8\n",
    "c_in = 7  # aka channels, features, variables, dimensions\n",
    "c_out = 2\n",
    "seq_len = 10\n",
    "xb2 = torch.randn(bs, c_in, seq_len)\n",
    "model1 = MultiTSTPlus([2, 5], c_out, seq_len, )\n",
    "model2 = MultiTSTPlus([[0,2,5], [0,1,3,4,6]], c_out, seq_len)\n",
    "test_eq(model1.to(xb2.device)(xb2).shape, (bs, c_out))\n",
    "test_eq(model1.to(xb2.device)(xb2).shape, model2.to(xb2.device)(xb2).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): GELU(approximate='none')\n",
       "    (1): fastai.layers.Flatten(full=False)\n",
       "    (2): LinBnDrop(\n",
       "      (0): Linear(in_features=2560, out_features=2, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1 = MultiTSTPlus([2, 5], c_out, seq_len, y_range=(0.5, 5.5))\n",
    "body, head = split_model(model1)\n",
    "test_eq(body.to(xb2.device)(xb2).ndim, 3)\n",
    "test_eq(head.to(xb2.device)(body.to(xb2.device)(xb2)).ndim, 2)\n",
    "head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MultiTSTPlus([2, 5], c_out, seq_len, pre_norm=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([8, 2])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): AdaptiveAvgPool1d(output_size=1)\n",
       "  (1): Reshape(bs)\n",
       "  (2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (3): Linear(in_features=128, out_features=512, bias=False)\n",
       "  (4): ReLU(inplace=True)\n",
       "  (5): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (6): Linear(in_features=512, out_features=2, bias=False)\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bs = 8\n",
    "n_vars = 3\n",
    "seq_len = 12\n",
    "c_out = 2\n",
    "xb = torch.rand(bs, n_vars, seq_len)\n",
    "net = MultiTSTPlus(n_vars, c_out, seq_len)\n",
    "change_model_head(net, create_pool_plus_head, concat_pool=False)\n",
    "print(net.to(xb.device)(xb).shape)\n",
    "net.head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([8, 5, 2, 10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): create_conv_lin_nd_head(\n",
       "    (0): Conv1d(128, 10, kernel_size=(1,), stride=(1,))\n",
       "    (1): Linear(in_features=12, out_features=10, bias=True)\n",
       "    (2): Transpose(-1, -2)\n",
       "    (3): Reshape(bs, 5, 2, 10)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bs = 8\n",
    "n_vars = 3\n",
    "seq_len = 12\n",
    "c_out = 10\n",
    "xb = torch.rand(bs, n_vars, seq_len)\n",
    "new_head = partial(conv_lin_nd_head, d=(5 ,2))\n",
    "net = MultiTSTPlus(n_vars, c_out, seq_len, custom_head=new_head)\n",
    "print(net.to(xb.device)(xb).shape)\n",
    "net.head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "IPython.notebook.save_checkpoint();",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/nbs/050_models.TSTPlus.ipynb saved at 2023-03-19 14:21:07\n",
      "Correct notebook to script conversion! 😃\n",
      "Sunday 19/03/23 14:21:10 CET\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#|eval: false\n",
    "#|hide\n",
    "from tsai.export import get_nb_name; nb_name = get_nb_name(locals())\n",
    "from tsai.imports import create_scripts; create_scripts(nb_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
